Нефиксированные предупреждения будут , рано или поздно, вывод к ошибкам в Вашем коде .

Отладка отказа сегментации, например, требует, чтобы программист проследил корень (причина) отказа, который обычно располагается в предшествующем месте в Вашем коде, чем строка, которая в конечном счете вызвала отказ сегментации.

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

Фиксация предупреждения приводит к решению проблемы.. Классик!

демонстрация А вышеупомянутого.. Рассмотрите следующий код:

#include <stdio.h>

int main(void) {
  char* str = "Hello world!";
  int idx;

  // Colossal amount of code here, irrelevant to 'idx'

  printf("%c\n", str[idx]);

  return 0;
}

, который при компиляции с флагом "Wextra", переданным GCC дает:

main.c: In function 'main':
main.c:9:21: warning: 'idx' is used uninitialized in this function [-Wuninitialized]
    9 |   printf("%c\n", str[idx]);
      |                     ^

, который я мог , игнорируют и выполняют код так или иначе.. И затем я засвидетельствовал бы, что "главная" сегментация дает сбой, поскольку раньше говорил мой IP epicurus преподаватель:

отказ Сегментации

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

До, однажды, они нашли theirselves в ситуации, где обнаруживание, которое i используется неинициализированное, таким образом это имеет значение мусора, которое приводит к индексации строки (путь) вне из его границ, который приводит к отказу сегментации.

, Если бы только они не проигнорировали предупреждение, они сразу нашли бы ошибку!

Это - определенный ответ на C, и почему это намного более важно для C, чем к чему-либо еще.

#include <stdio.h>
int main()
{
   FILE *fp = "some string";
}

Этот код компилирует с предупреждение . Что и должно быть ошибками на примерно любом языке на планете (запрещающий ассемблер), предупреждения в C. Предупреждения в C являются почти всегда скрытыми ошибками. Предупреждения должны быть зафиксированы, не подавлены.

С gcc, мы делаем это как gcc -Wall -Werror.

Это было также причиной высокого rantyness о некотором MS незащищенные предупреждения API. Большинство людей программирование C научилось на горьком опыте для обработки предупреждений как ошибок и этого материала, появилось, который просто не был тем же видом вещи и хотел непортативные меры.

Другие ответы превосходны, и я не хочу повторять то, что они сказали.

Еще один аспект к, "почему включают предупреждения", который не был правильно затронут, - то, что они помогают чрезвычайно с обслуживанием кода. Когда Вы пишете программу значительного размера, становится невозможно сохранить все это в Вашей голове сразу. У Вас обычно есть функция или три, что Вы активно пишете и думаете о, и возможно файл или три на Вашем экране, к которому можно обратиться, но объем программы существует в фоновом режиме где-нибудь, и необходимо положить, что это продолжает работать.

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

Берут, например, лязг, предупреждающий -Wswitch-enum. Это инициировало предупреждение, если Вы используете переключатель на перечислении и пропускаете одно из возможных перечислимых значений. Это - что-то, что Вы могли бы думать, будет маловероятная ошибка сделать: Вы, вероятно, по крайней мере, посмотрели на список перечислимых значений, когда Вы записали оператор переключения. У Вас мог бы даже быть IDE, который генерировал опции переключателя для Вас, не оставив места для человеческой ошибки.

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

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

Поскольку кто-то, кто работает с наследием, встроил код C, включение предупреждений компилятора помогло показать большую слабость и области для исследования, когда предложение фиксирует. В gcc использование -Wall и -Wextra и даже -Wshadow стали жизненно важными. Я не собираюсь идти каждая опасность, но я перечислю некоторых, которые открылись, который помог показать проблемы кода.

Переменные, оставляемые позади

, Этот может легко указать на незаконченную работу и области, которые не могли бы использовать все переданные переменные, которые могли быть проблемой. Давайте посмотрим на простую функцию, которая может инициировать это:

int foo(int a, int b)
{
   int c = 0;

   if (a > 0)
   {
        return a;
   }
   return 0;
}

Просто компиляция этого без - Стена или-Wextra не возвращают проблем. - стена скажет Вам, хотя это c никогда не используется:

foo.c: В функции ‘foo’:

нечто c:9:20: предупреждение: неиспользуемая переменная ‘c’ [-Wunused-переменная]

-Wextra также скажет Вам, что Ваш параметр b ничего не делает:

foo.c: В функции ‘foo’:

нечто c:9:20: предупреждение: неиспользуемая переменная ‘c’ [-Wunused-переменная]

нечто c:7:20: предупреждение: неиспользованный параметр ‘b’ [-Wunused-параметр] международное нечто (интервал a, интервал b)

затенение Глобальной переменной

Этот бит трудно и не показал вплоть до -Wshadow, использовался. Давайте изменим пример выше, чтобы просто добавить, но просто, оказывается, существует глобальное с тем же именем как локальное, которое вызывает много беспорядка при попытке использовать обоих.

int c = 7;

int foo(int a, int b)
{
   int c = a + b;
   return c;
}

, Когда-Wshadow был включен, легко определить эту проблему.

нечто c:11:9: предупреждение: объявление ‘c’ теней глобальное нечто c:1:5 [-Wshadow]

объявления:примечание: затененное объявление здесь

Строки формата

, Это не требует никаких дополнительных флагов в gcc, но это имеет все еще быть источником проблем в прошлом. Простая функция, пытающаяся распечатать данные, но, имеет ошибку форматирования, мог быть похожим на это:

void foo(const char * str)
{
    printf("str = %d\n", str);
}

Это не печатает строку, так как флаг форматирования является неправильным, и gcc счастливо скажет Вам, что это, вероятно, не, что Вы хотели:

foo.c: В функции ‘foo’:

нечто c:10:12: предупреждение: отформатируйте †˜, % d’ ожидает аргумент типа ‘int’, но аргумент 2 имеет тип ‘const символ *’ [-Wformat =]

, Это всего три из многих вещей, которые компилятор может проверить дважды для Вас. Существует много других как использование неинициализированной переменной, на которую указали другие.

Предупреждения состоят из лучшего совета, который некоторые самые квалифицированные разработчики C++ могли испечь в приложение. Их стоит иметь в наличии.

C++, будучи полным по Тьюрингу языком, имеет много случаев, где компилятор должен просто положить, что Вы знали то, что Вы делаете. Однако существует много случаев, где компилятор может понять, что Вы, вероятно, не намеревались записать то, что Вы записали. Классическим примером является printf () коды, которые не соответствуют аргументам или станд.:: строки передали printf (не, что это когда-либо происходит со мной!). В этих случаях код, который Вы написали, не является ошибкой. Это - допустимое выражение C++ с допустимой интерпретацией для компилятора для действия на. Но компилятор имеет сильную догадку, что Вы просто пропустили что-то, что легко для современного компилятора обнаружить. Это предупреждения. Они - вещи, которые очевидны для компилятора, с помощью всех строгих правил C++ в его распоряжении, которое Вы, возможно, пропустили.

Выключение предупреждений или игнорирование их, похоже на желание проигнорировать бесплатный совет от более квалифицированных, чем Вы. Это - урок в huberis, который заканчивается или когда Вы летите слишком близкий к солнцу и Вашей плавке крыльев, или ошибка повреждения памяти происходит. Между этими двумя я возьму падение с неба любой день!

"Предупреждения обработки как ошибки" экстремальная версия этой философии. Идея здесь состоит в том, что Вы решаете каждый предупреждение, что компилятор дает Вам - Вы слушаете каждый бит бесплатного совета и действуете на него. Является ли это хорошей моделью для разработки для Вас, зависит от команды и какой продукт Вы продолжаете работать. Это - аскетический подход, который мог бы иметь монах. Для некоторых это работает отлично. Для других это не делает.

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

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

Использование корректный тип, возвратите то значение, оцените то возвращаемое значение. Займите время и отразите, что "Это - действительно корректный тип в этом контексте?" "Я должен возвратить это?" И важная персона; "Этот код собирается быть портативным в течение следующих 10 лет?"

Вырабатывают привычку написания кода без предупреждений во-первых.

Обработка предупреждений как ошибки является просто средней из самодисциплины: Вы компилировали программу для тестирования той новейшей функции, но Вы не можете , пока Вы не фиксируете неаккуратные части. Нет никакой дополнительной информации Werror, обеспечивает, это просто устанавливает приоритеты очень ясно:

не добавляют новый код, пока Вы не решаете проблемы в существующем коде

, Это - действительно мышление, это важно, не инструменты. Вывод диагностики компилятора является инструментом. MISRA (для встроенного C) является другим инструментом. Это не имеет значения, какой Вы используете, но возможно предупреждения компилятора самый легкий инструмент, который можно получить (это - всего один флаг для установки), и соотношение сигнал/шум очень высоко. Таким образом, нет никакой причины не для использования его.

инструмент No безошибочен. Если Вы запишете const float pi = 3.14;, то большинство инструментов не скажет Вам об определении ПЂ с плохой точностью, которая может привести к проблемам в будущем. Большинство инструментов не повысит бровь на if(tmp < 42), даже если будет обычно известно, что давание переменных бессмысленные имена и использование магических чисел являются путем к аварии в больших проектах. необходимо понять, что любой "быстрый тест" кодирует Вас, запись просто что: тест, и необходимо разобраться в нем, прежде чем Вы будете идти дальше к другим задачам, в то время как Вы все еще видите его недостатки. Если Вы уезжаете, который кодирует, как, отлаживая, если после пребывания в течение двух месяцев, добавляя новые опции, будет значительно более твердым.

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

Необходимо всегда включать предупреждения компилятора, потому что компилятор может часто говорить Вам что случилось с Вашим кодом. Чтобы сделать это, Вы передаете -Wall -Wextra компилятору.

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

Некоторое предупреждение может означать возможную семантическую ошибку в коде или возможный UB. Например, ; после if(), неиспользуемая переменная, глобальная переменная, замаскированная локальным, или сравнение со знаком и неподписанных. Много предупреждений связаны со статическим анализатором кода в компиляторе или к нарушениям стандарта ISO, обнаруживаемого во время компиляции, которые "требуют диагностики". В то время как те случаи могут быть законными в одном особом случае, они были бы результатом вопросов проектирования большую часть времени.

Некоторые компиляторы, например, gcc, имеют параметр командной строки для активации "предупреждений как ошибок" режим, это - хорошее, если жестокий, инструмент для обучения кодеров новичка.

C является, заметно, довольно низкоуровневым языком, когда ЯПВУ идут. C++, хотя это, могло бы казаться, было бы значительно высокоуровневым языком, чем C, все еще совместно использует много своих черт. И одна из тех черт - то, что языки были разработаны программистами для программистов - и конкретно программисты, которые знали то, что они делали.

[Для остальной части этого ответа я собираюсь сфокусироваться на C. Большая часть того, что я скажу также, относится к C++, хотя, возможно, не как сильно. Хотя, поскольку Bjarne Stroustrup заметно сказал, "C помогает выстрелить себе в ногу; C++ мешает, но когда Вы делаете он сдувает Ваш целый участок. "]

, Если Вы знаете то, что Вы делаете - действительно , знают то, что Вы делаете - иногда Вам, вероятно, придется "нарушить правила". Но большую часть времени, большинство из нас согласится, что полные благих намерений правила не допускают нас всех в проблему, и что экстравагантно нарушение тех правил все время является плохой идеей.

, Но в C и C++, существуют удивительно большие количества вещей, которые можно сделать, которые являются "плохими идеями", но которые официально не противоречат правилам "". Иногда они - плохая идея часть времени (но могли бы быть защитимые другие времена); иногда они - плохая идея фактически все время. Но традиция всегда была не для предупреждения об этих вещах - потому что, снова, предположение - то, что программисты знают то, что они делают, они не сделали бы этих вещей без серьезного основания, они будут раздражаться набором ненужных предупреждений.

, Но конечно не все программисты действительно знают то, что они делают. И, в частности, каждый программист C (неважно, как опытный) проходит фазу того, чтобы быть началом C программист. И даже опытные программисты C могут стать небрежными и сделать ошибки.

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

, Таким образом, оказывается, что большую часть времени предупреждения являются хорошей идеей, в конце концов. Даже опытные программисты учились (на самом деле, это" особенно , опытные программисты учились"), что в итоге предупреждения имеют тенденцию приносить больше пользы, чем вреда. В течение каждого раза Вы сделали что-то не так сознательно, и предупреждение было неприятностью, существуют, вероятно, по крайней мере десять раз, Вы сделали что-то не так случайно, и предупреждение сохранило Вас от дальнейшей проблемы. И большинство предупреждений может быть отключено или работало вокруг в течение тех нескольких раз, когда Вы действительно хотите сделать "неправильную" вещь.

(Классическим примером такой "ошибки" является тест if(a = b). Большую часть времени это - ошибка, таким образом, большинство компиляторов в эти дни предупреждает об этом - некоторые даже по умолчанию. Но если Вы действительно требуемый, чтобы и присвоиться b к a и протестировать результат, можно отключить предупреждение путем ввода if((a = b)).)

второй вопрос, почему Вы хотели бы попросить, чтобы компилятор рассматривал предупреждения как ошибки? Я сказал бы, что это из-за человеческой натуры, а именно, слишком легкой реакции высказывания, "О, это - просто предупреждение, это не так важно, я очищу это позже". Но если Вы - прокрастинатор (и я не знаю о Вас, но я ужасен прокрастинатор), легко отложить обязательно очистка для в основном когда-либо - и если Вы вырабатываете привычку игнорирования предупреждений, это становится легче и легче отсутствовать важный предупреждающее сообщение, это находится там, незамеченное, посреди всего те Вы игнорируете.

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

Лично, я не так настойчив об обработке предупреждений как ошибки. (На самом деле, если я честен, я могу сказать, что фактически никогда не включаю ту опцию в своем "персональном" программировании.), Но можно быть уверены, что мне включили ту опцию на работе, где наше руководство по стилю (который я записал) передает под мандат свое использование. И я сказал бы - я подозреваю, что большинство профессиональных программистов сказало бы - что любой магазин, который не рассматривает предупреждения как ошибки в C, ведет себя безответственно, не придерживается обычно принятых промышленных лучших практик.

Успокойтесь: Вы не имеете к, это не необходимо. - стена и-Werror были разработаны осуществляющими рефакторинг код маньяками для себя: это было изобретено разработчиками компилятора, чтобы не повреждать существующие сборки после обновлений компилятора на стороне пользователя . Функция - ничто, но все о решении повредить или не повредить сборку.

Это полностью до Вашего предпочтения для использования его или нет. Я использую все это время, потому что это помогает мне зафиксировать свои ошибки.

Предупреждения компилятора в C++ очень полезны по некоторым причинам.

1 - Это разрешает показывать Вам, где можно было сделать ошибку, кто может повлиять на конечный результат операций. Например, если Вы не инициализировали переменную или если Вы помещаете "=" вместо "==" (существуют только примеры)

2 - Она разрешает также показывать Вам, где Ваш код не, соответствуют стандарту C++. Это полезно, потому что, если код, соответствуют фактическому стандарту, будет легко переместить код в другую plateform, например.

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

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

То, что компиляторы C++ принимают код компиляции, который, очевидно, приводит к неопределенному поведению во всем , является главным дефектом в компиляторах. Причина они не фиксируют это, состоит в том, потому что выполнение так, вероятно, повредило бы некоторые применимые сборки.

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

Необходимо определенно включить предупреждения компилятора, поскольку некоторые компиляторы плохи при создании отчетов, что некоторые общие ошибки программирования, включая following:-

-> инициализируют переменную, забыт->, возвращают значение от функции, пропущены-> простые аргументы в printf и scanf семействах, не соответствующих строке формата, функция используется, не будучи объявленным заранее, хотя происходит в c только

Поэтому, поскольку эти функции можно обнаружить и сообщить, просто обычно не по умолчанию; таким образом, эту функцию нужно явно требовать через параметры компилятора.

Существуют только один проблема с обработкой предупреждений как ошибки: Когда Вы используете код, прибывающий из других источников (например, micro$ ** t библиотеки, проекты с открытым исходным кодом), они не сделали свое задание правильно, и компиляция их кода генерирует тонны из предупреждений.

я всегда пишу свой код, таким образом, он не генерирует предупреждений или ошибок, и убирает, он вплоть до него компилирует, не генерируя постороннего шума. Мусор, с которым я должен работать, ужасает меня, и я изумлен, когда я должен разработать большой проект и наблюдать, что поток предупреждений проходит, где компиляция должна только объявлять, какие файлы это обработало.

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

ПРЕДУПРЕЖДЕНИЯ КОМПИЛЯТОРА ЯВЛЯЮТСЯ ВАШИМ ДРУГОМ (не крик, верхний регистр для акцента).

я работаю над Фортраном прежней версии 77 систем. Компилятор говорит мне ценные вещи: неверные типы данных аргумента на вызове подпрограммы, с помощью локальной переменной перед значением были установлены в переменную, если у меня есть переменная или аргумент подпрограммы, который не используется. Это почти всегда ошибки.

Предотвращение длинного сообщения: Когда мой код компилирует чисто, 97%, он работает. Другой парень я работаю с компиляциями со всеми предупреждениями прочь, проводит часы или дни в отладчике, затем просит, чтобы я помог. Я просто компилирую его код с предупреждениями на и говорю ему, что зафиксировать.

Предупреждение является неизбежной ошибкой. Таким образом, необходимо включить предупреждения компилятора и убрать код для удаления любого предупреждения.

Я когда-то работал на большое (Fortune 50) компания, которая произвела электронное испытательное оборудование.

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

Это - чертов кошмар, когда ошибки происходят.

После того положения, мне повезло быть нанятым в качестве первого разработчика в новом запуске.

я не поощрил 'предупреждение' политика для всех сборок с набором уровней предупреждения компилятора быть довольно шумным.

Наша практика должна была использовать #pragma, предупреждающий - продвигают/запрещают/выталкивают для кода, что разработчик был уверен, был прекрасен действительно, наряду с оператором журнала на уровне отладки, на всякий случай.

Эта практика работала хорошо на нас.