Войти
ФлеймФорумПроЭкты

Ü (Programmiersprache) (37 стр)

Страницы: 134 35 36 37 38 39 Следующая »
#540
(Правка: 14:35) 14:24, 16 окт. 2019

}:+()___ [Smile]
>Если язык с занулением и правильное значение равно нулю, то ему повезло, если нет — то ошибка никуда не делась.

В релизе я хочу чтобы мне везло.

>Более того, такие ошибки становится намного сложнее ловить, ибо сторонний человек не сможет сразу сказать, действительно ли там должен быть ноль или это пропущенная инициализация.

Что ты понимаешь под "ловить ошибки"?
Если есть способ воспроизведения - ошибку гораздо проще исправить, чем если его нет. Гарантированная инициализация переменных убирает зависимость от предыдущих действий и упрощает воспроизведение ошибок.
Об ошибке воспроизводящейся у малого количества пользователей совершивших конкретную нетривиальную последовательность действий никто не узнает.

>В случае языка без зануления эта ошибка обнаруживается за один запуск валгринда.

Это если путь выполнения с использованием неинициализированной переменной есть в твоем тесте.

>Вот что, действительно, стоит добавлять в компиляторы, так это разнообразные санитайзеры.
>Чтобы скомпилированная в дебаге программа сразу крашилась на попытке доступа к неинициализированной переменной.

Речь не про дебаг, а про релиз.


#541
14:37, 16 окт. 2019

Panzerschrek[CN]
> Если язык позволяет такие непотребства - это ошибка дизайне в языка.
А если переменная предназначена для записи, причем сильно после создания?
Выдумывать какое-то левое значение просто чтобы заткнуть компилятор?
И опять теряем возможность обнаружить ошибку, когда читаем переменную, пропустив задание по какой-то причине.

CD
> В релизе я хочу чтобы мне везло.
А я хочу, чтобы в релизе ошибок было меньше.

> Что ты понимаешь под "ловить ошибки"?
Это значит, что когда происходит какая-то хрень непонятно почему я хочу найти причину.

> Это если путь выполнения с использованием неинициализированной переменной есть в твоем тесте.
Нетестируемый код с вероятностью 99% сломан и никакое зануление тут не спасет.

#542
(Правка: 18:30) 15:33, 16 окт. 2019

}:+()___ [Smile]
>> Это если путь выполнения с использованием неинициализированной переменной есть в твоем тесте.
> Нетестируемый код с вероятностью 99% сломан и никакое зануление тут не спасет.
Путь выполнения и код это не одно и тоже
Если есть десять подряд if-ов, это не значит что пока не проведено 2^10 тестов есть 99% шанс бага.

Если в первом if инициализируется указатель или индекс, а в десятом по этому указателю/индексу что-то пишется, и есть баг в условии, то без зануления я даже не хочу думать о таком.

#543
18:23, 16 окт. 2019

}:+()___ [Smile]
> Выдумывать какое-то левое значение просто чтобы заткнуть компилятор?
Вынеси код инициализации в отдельную функцию. Если ты объявляешь переменную, а до конца инициализируюшь её через десяток if-ов - то это быдлокод.

#544
18:34, 16 окт. 2019

Panzerschrek[CN]
> Если ты объявляешь переменную, а до конца инициализируюшь её через десяток if-ов - то это быдлокод.
Для одиночной переменной — может быть (и то, иногда выделение в дополнительную функцию еще больший быдлокод), в более сложных случаях такое встречается сплошь и рядом.

Например, мы заполняем массив, причем в запутанном порядке, который определяется другим тяжелым кодом.
Или мы ваяем класс для асинхронного вычисления чего-то сложного в отдельном потоке.
Понятно, что всегда можно извратиться и обойтись только инициализированными переменными, но любое извращение — это усложнение кода на ровном месте и повышение градуса быдлокода.

#545
18:38, 16 окт. 2019

}:+()___ [Smile]
> мы заполняем массив, причем в запутанном порядке
Очень нечастый случай. Приведи примеры мест, где это надо. Тут, опять же, надо гарантировать, что ты проинициализируешь все элементы массива. Кто даст гарантию, что ты не забудешь чего-то?

> ваяем класс для асинхронного вычисления чего-то сложного в отдельном потоке
Вся низкоуровневая асинхронщина реализуется один раз, желательно вообще, в стандартной библиотеке. Там можно и поизвращаться с uninitialized. В клиентском коде у тебя уже должны быть примитивы многопоточности без проблем с инициализацией.

#546
19:43, 16 окт. 2019

Panzerschrek[CN]
> Очень нечастый случай. Приведи примеры мест, где это надо.
В половине случаев когда порядок данных на входе не совпадает с порядком данных на выходе.

> Кто даст гарантию, что ты не забудешь чего-то?
Валгринд. Но ты не понял мой главный поинт: мне не нужен 0 там, где должно быть 5, но я забыл заполнить.

> Вся низкоуровневая асинхронщина реализуется один раз, желательно вообще, в стандартной библиотеке.
Да причем тут асинхронщина. Есть у меня класс, который инкапсулирует сложный расчет.
В нем лежат входные данные, всякие временные массивы и выходные данные.
Я заполняю данные, ставлю его в очередь на счет, потом забираю результат.
Соответственно, мне нужно ловить случай когда беру результат до расчета.

#547
22:36, 16 окт. 2019

}:+()___ [Smile]
> порядок данных на входе не совпадает с порядком данных на выходе
В таком случае у тебя не массив, а какой-то контейнер с ключами должен быть.

> Валгринд.
Штука хорошая, но по сути это костыль. Сначала пишем код на языке, который позволяет непотребство писать, а потом анализаторами, отладчиками, профилировщиками ищем, что же там не так.

> В нем лежат входные данные, всякие временные массивы и выходные данные.
Говнокод же.
Правильный подход вот такой:

fn Foo( InData in_data ) : OutData;

> мне нужно ловить случай когда беру результат до расчета.
Открой для себя std::future.

#548
(Правка: 22:56) 22:55, 16 окт. 2019

}:+()___ [Smile]
> Выдумывать какое-то левое значение просто чтобы заткнуть компилятор?
В расте можно так делать

let foo = {
   let mut abc = 123;
   abc *= 2;
   ...
   abc
};

abc в конце становится результатом всего блока и присваивается foo, и это очень удобно - переменная гарантированно инициализирована и промежуточные шаги спрятаны в своей области видимости

#549
0:06, 17 окт. 2019

mr.DIMAS
В Си так, кстати, тоже можно. Правда, это расширение GCC вроде.

#550
0:18, 17 окт. 2019
int foo = [&](){
  int abc=123;
  abc *= 2;
  ...
  return abc;
} ();
#551
(Правка: 0:18) 0:18, 17 окт. 2019
const int i = []()
{
    int a = 0;
    ++a;
    ++a;
    return a;
}();
upd: lol
#552
(Правка: 8:47) 8:46, 17 окт. 2019
enum E { A, B, C };
let e = E::A;
let foo = match e {
  E::A => { 
    let mut abc = 123;
    abc += 1;
    abc
  }
  E::B => {
    42
  }
  E::C => {
    println!("Rust is better than C++")
    100500
  }
};
шах и мат аметисты
#553
10:21, 17 окт. 2019

1 frag / 2 deaths
> int foo = [&](){
> int abc=123;
> abc *= 2;
> ...
> return abc;
> } ();
Ужос, правда?

#554
(Правка: 12:48) 12:44, 17 окт. 2019

mr.DIMAS
Зато в крестах так можно.

int foo(){
    int i = 2;
    switch(i){
        i++;
        switch(i) --i;
        i++;
        case 0:{
            case 3: return i;
        }
        return 2;
        if(i < 10){
            case 1:{
                default:case 4:{  }
                break;
            }
            for(i=0; i < 10; i++){
                case 2:;
            }
        }
    }
    return i;
}

Ну красота же!

Страницы: 134 35 36 37 38 39 Следующая »
ФлеймФорумПроЭкты