Логические ошибки в программировании примеры

Виды ошибок в программах

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

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

Итак, основных вида всего три:

• Синтаксические ошибки
• Логические ошибки
• Ошибки выполнения программы

Синтаксические ошибки в программах

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

Синтаксические ошибки — это ошибки синтаксиса (а то бы вы не догадались))). То есть ошибки правил языка. Например, для Паскаля это будет синтаксической ошибкой:

WriteLn('Hello, World !!!')
ReadLn;

Потому что после первой строки нет точки с запятой.

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

Потому что в сообщении чётко сказано:

Syntax error, ";" expected but "identifier READLN" found

что можно перевести как

синтаксическая ошибка, ";" ожидалось, но "READLN" найден

То есть компилятор говорит нам: я ожидал увидеть точку с запятой, а нашёл идентификатор READLN.

Логические ошибки в программах

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

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

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

Пример логической ошибки:

for i := 1 to 10 do
  if i = 15 then WriteLn('i = 15');

Здесь мы сравниваем значение i с числом 15, и выводим сообщение, если i = 15.
Но фишка в том, что в данном цикле i не будет равно 15 НИКОГДА, потому что в цикле переменной i присваиваются значения от 1 до 10.

Эта ошибка довольно безобидная. Здесь мы имеем просто бессмысленный код, который не причинит никакого вреда.
Однако представьте, что программа должна выдавать какой-то сигнал тревоги, если i = 15. Тогда получится, что никакого сигнала пользователь никогда не услышит, даже если случилось что-то страшное. А всё потому, что программист немного ошибся. Вот так вот и падают ракеты и самолёты…

Распространённые логические ошибки в С++ вы можете посмотреть здесь.

Ошибки времени выполнения программы

Даже если исходный код не содержит ни логических, не синтаксических ошибок, это ещё не означает, что ваша программа безупречна. Потому что ошибки могут возникнуть в ходе выполнения программы. Например, случайно будет удалён файл, который должна читать программа, и она не сможет его найти. Если не принять мер, то программа может завершиться аварийно. А пользователям такое поведение программ очень не нравится.

Одна из самых рапространённых ошибок времени выполнения — это неожиданное деление на ноль. Пример:

Write('y = ');
ReadLn(y);
x := 100 / y;
WriteLn('100 / ', y, ' = ', x);

Что здесь такого? Всё правильно и с точки зрения логики, и с точки зрения синтаксиса. И в большинстве случаев программа отработает без каких-либо неожиданностей.

Но представьте, что пользователь введёт ноль. Что тогда будет? Правильно — попытка деления на ноль. А на ноль делить нельзя. Поэтому во время выполнения этой программы произойдёт ошибка, которая очень расстроит пользователя. Потому что в случае, например, с консольным приложением программа просто закроется, и пользователь не поймёт, что это было. Но зато поймёт, что программа — говно, и программы от этого разработчика лучше больше никогда не использовать.

В данном случае, если вы не уверены на 100%, что y будет отличаться от нуля, надо всегда делать проверку на ноль. И хороший код должен быть хотя бы таким:

Write('y = ');
ReadLn(y);
if y = 0 then WriteLn('ERROR: y = 0')
else
  begin
    x := 100 / y;
    WriteLn('100 / ', y, ' = ', x);
  end;

Ну что же. На этом с видами ошибок пока всё. Изучайте программирование и поменьше ошибайтесь.

Потому что в сообщении чётко сказано:

Syntax error, ";" expected but "identifier READLN" found

что можно перевести как

синтаксическая ошибка, ";" ожидалось, но "READLN" найден

То есть компилятор говорит нам: я ожидал увидеть точку с запятой, а нашёл идентификатор READLN.

Логические ошибки в программах

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

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

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

Пример логической ошибки:

for i := 1 to 10 do
  if i = 15 then WriteLn('i = 15');

Здесь мы сравниваем значение i с числом 15, и выводим сообщение, если i = 15.
Но фишка в том, что в данном цикле i не будет равно 15 НИКОГДА, потому что в цикле переменной i присваиваются значения от 1 до 10.

Эта ошибка довольно безобидная. Здесь мы имеем просто бессмысленный код, который не причинит никакого вреда.
Однако представьте, что программа должна выдавать какой-то сигнал тревоги, если i = 15. Тогда получится, что никакого сигнала пользователь никогда не услышит, даже если случилось что-то страшное. А всё потому, что программист немного ошибся. Вот так вот и падают ракеты и самолёты…

Распространённые логические ошибки в С++ вы можете посмотреть здесь.

Ошибки времени выполнения программы

Даже если исходный код не содержит ни логических, не синтаксических ошибок, это ещё не означает, что ваша программа безупречна. Потому что ошибки могут возникнуть в ходе выполнения программы. Например, случайно будет удалён файл, который должна читать программа, и она не сможет его найти. Если не принять мер, то программа может завершиться аварийно. А пользователям такое поведение программ очень не нравится.

Одна из самых рапространённых ошибок времени выполнения — это неожиданное деление на ноль. Пример:

Write('y = ');
ReadLn(y);
x := 100 / y;
WriteLn('100 / ', y, ' = ', x);

Что здесь такого? Всё правильно и с точки зрения логики, и с точки зрения синтаксиса. И в большинстве случаев программа отработает без каких-либо неожиданностей.

Но представьте, что пользователь введёт ноль. Что тогда будет? Правильно — попытка деления на ноль. А на ноль делить нельзя. Поэтому во время выполнения этой программы произойдёт ошибка, которая очень расстроит пользователя. Потому что в случае, например, с консольным приложением программа просто закроется, и пользователь не поймёт, что это было. Но зато поймёт, что программа — говно, и программы от этого разработчика лучше больше никогда не использовать.

В данном случае, если вы не уверены на 100%, что y будет отличаться от нуля, надо всегда делать проверку на ноль. И хороший код должен быть хотя бы таким:

Write('y = ');
ReadLn(y);
if y = 0 then WriteLn('ERROR: y = 0')
else
  begin
    x := 100 / y;
    WriteLn('100 / ', y, ' = ', x);
  end;

Ну что же. На этом с видами ошибок пока всё. Изучайте программирование и поменьше ошибайтесь.

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

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

Выявить этот вид багов удается только на этапе тестирования. И хорошо, если ошибку удается исправить локальной «заплаткой». Нередко приходится менять практически весь алгоритм. А это – дополнительные затраты времени, сил, а в коммерческих проектах – финансовые, а иногда и репутационные потери.

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

Алгоритм – основа всех основ

Написание алгоритма – это самый первый этап разработки, когда идеи только обретают форму еще без привязки к языку программирования. Нередко начинающие программисты относятся к созданию алгоритма «спустя рукава» — делают только «общие наброски» или вообще приступают к кодингу сразу без предварительной проработки логики «на бумаге».

Такой подход возможен при решении учебных задач на 10-15 строк кода. Но при работе над серьезным программным продуктом пренебрежение алгоритмом – почти гарантированный путь к логическим ошибкам и катастрофическим результатам.

Как работать с алгоритмом:

• Начинайте с малого. Запишите алгоритм упрощенно, в виде «черных ящиков» (логических блоков без подробностей их работы). Это поможет оценить работоспособность идеи в целом.
• Двигайтесь сверху вниз. Сначала – общая идея «в целом», далее – детализация основных функций и так далее. Не бойтесь ставить «заглушки» и прорабатывать мелкие детали в последнюю очередь. Двигаться сверху вниз проще и с точки зрения логики, и психологически.
• Пишите команды «от имени компьютера». Помните, что вы имеете дело не с человеком, а с компьютером, который буквально выполняет команды и после каждого шага ждет ответа на вопрос «что делать». Например, логический блок «сохранение документа» будет понятен вам, но не компьютеру. Он вполне подойдет на этапе крупных блоков в качестве заглушки. Но далее придется проработать все действия пошагово с учетом выбранного языка программирования.
• Делите код на отдельные модули (блоки), которые можно будет запускать отдельно друг от друга. Это сильно облегчит как алгоритмизацию, так и процесс отладки.
• Читайте алгоритм «как будто компьютер». Проверяйте себя на каждом этапе. Главное правило – одинаковые данные всегда должны вести к одинаковым результатам.

Итак, алгоритм написан и проверен со всех сторон. Выбран язык программирования. Начинается процесс кодинга. Давайте разбираться, на что обращать особое внимание.

«Не туда положил»: о типах данных

Здесь проблемы возникают в двух случаях:

1. При статической типизации в таких языках, как С++, Java или С# неверно определен тип переменной. Большинство подобных ошибок выявляет компилятор. Но здесь есть свои «лазейки» для багов. Например, в С# вполне возможно «положить» вещественное значение в целочисленную переменную. И оно просто округлится до целого. Т.е. вместо 1,3 у вас будет храниться значение 1. Само собой, все дальнейшие вычисления будут содержать ошибку.
2. При динамической типизации (JavaScript, Python, PHP) неявное приведение типов – самое обычное дело. А потому здесь даже компилятор промолчит в случае ошибки. Например, вы планируете получить целочисленное значение, для чего отправляете результаты вычислений в переменную типа int. Но программа видит «знаки после запятой», и переменная без вашего участия меняет тип на float.

Самый известный пример подобной ошибки – деление двух целых чисел с остатком.

int a = 25;

int b = 8;

float c = a/b;

Console.Write(c);

Как вы думаете, какое число будет выведено на экран после выполнения последней строки? По идее, это должно быть 3,125. Но, например, в C# вы увидите целую цифру «3». Причем, тип переменной С будет float, как вы и заказывали.

Здесь проблема в другом: компилятор сначала проводит целочисленное деление, так как определяет переменные A и B как относящиеся к типу int. И полученный результат отправляет в переменную C (тип float). Целое значение (32 разряда) прекрасно помещается в 64-разрядный float, отведенный под хранение результата. Компилятор не видит ошибки. А у вас в программе появляются неточные вычисления, которые могут повлечь за собой большие проблемы.

Аналогичным образом компилятор округлит значение до целого и в Python 2. А уже в Python 3 алгоритм преобразования типов сработает иначе: сначала определится тип переменной, куда отправляется значение, а потом будет проводиться деление. После компиляции кода в Python 3 вы получите c=3,125.

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

Высвобождение ресурсов: до 100% загрузки процессора

Если вы работаете с языком, где реализована автоматическая сборка мусора, внимательно следите за тем, как происходит высвобождение ресурсов. В отдельных случаях эта полезная функция может начать работать во вред: отбирать для себя максимум памяти, загружать дополнительными задачами процессор, замедлять и даже «подвешивать» программу.

Например, в Java этот процесс работает так:

• Виртуальная машина проводит поиск ненужных объектов;
• Составляет из них очередь на удаление;
• По мере продвижения очереди очищает ячейки памяти.

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

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

Намного надежнее своевременно применять функции типа try-with-resources и try-finally. И все ресурсы очищать в том коде, где вы их получили.

И еще: не забывайте закрывать сессии и файлы сразу после того, как они перестают быть нужны. Это должно быть также естественно, как закрыть скобку в коде.

Конфликт потоков: кто первый успеет?

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

Например: первый поток в результате вычислений получает значение 1, отправляет его в переменную. В это время второй поток перехватывает доступ и обнуляет эту переменную. А первый – сохраняет значение. В результате вы планировали запомнить значение 1. А у вас сразу после вычислений сохраняется 0. И далее копятся ошибка за ошибкой.

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

Переменные: склонность к глобализации

Эта ошибка популярна у новичков – стремление объявить сразу все переменные и сделать их глобальными. В результате таких действий вы:

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

На глобальном уровне определяют только необходимый минимум – те самые глобальные переменные, с которыми работают практически все модули. Все остальные объявляйте в тех модулях, где они работают. И не забывайте об идентификаторах ограничения доступа: public, private и protected.

Переполнение буфера в С/С++: «танцы на граблях»

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

Но нередко для экономии ресурсов программисты используют C-библиотеки. В этом случае очень важно следить за буферизацией. Дело в том, что языки C/С++ очень уязвимы к переполнению буфера. Если он окажется меньше, чем нужно для работы, программа попытается использовать память за пределами выделенного участка. Результат – многочисленные, можно сказать, легендарные ошибки, когда в обрабатываемые данные попадает «неведомый мусор».

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

Изучите особенности работы с буфером и методы борьбы с его переполнением, чтобы не пополнить число «танцующих на граблях с 30-летней историей».

Отладка и поиск логических багов

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

• Пользуйтесь возможностями отладчика вашей IDE. Ставьте контрольные точки, отражайте на консоли ход выполнения и значения переменных, переходите в «пошаговый режим» выполнения в наиболее «подозрительных» участках кода. Так вы быстрее сможете локализовать проблему.
• Помните: компилятор может неправильно указывать строку с ошибкой. Если вам повезло, и компилятор помог вам выявить баг, не спешите радоваться. При «завершении с ошибкой» вы видите номер строки, в которой выполнение программы стало невозможным. Если проблема в простейшей опечатке (синтаксис), то строка с багом вам известна. В случае логических ошибок вероятнее всего, проблема появилась на более ранних этапах работы программы. А в указанной строке была попытка использовать ошибочные данные, что и привело к аварийному завершению.
• Старый добрый листинг программы тоже может помочь. Если вы запутались и не знаете, что делать, распечатайте код и попробуйте его «выполнить» как будто вы – и есть компьютер. Шаг за шагом двигайте по командам. Переходите от блока к блоку так, как это делает программа. На каждом этапе вычисляйте и фиксируйте значения переменных (калькулятором пользоваться можно). И сверяйте результаты с ожидаемыми. Все в порядке? Двигайтесь дальше. Что-то не так? Ура! Вы локализовали баг. Можно возвращаться за компьютер и разбираться подробнее в этом фрагменте кода в отладчике.

И самое главное: не бойтесь что-то менять, в том числе, на глобальном уровне. Лучше переписать «сырой» код на раннем этапе разработки практически полностью, чем из-за серьезной логической ошибки терять в скорости и качестве работы программы, пытаясь использовать кучу «заплаток». От ошибок не застрахован никто. Потраченного времени жаль, но это – ваш личный практический опыт. А программа должна работать быстро, надежно и, самое главное, правильно.

From Wikipedia, the free encyclopedia

In computer programming, a logic error is a bug in a program that causes it to operate incorrectly, but not to terminate abnormally (or crash). A logic error produces unintended or undesired output or other behaviour, although it may not immediately be recognized as such.

Logic errors occur in both compiled and interpreted languages. Unlike a program with a syntax error, a program with a logic error is a valid program in the language, though it does not behave as intended. Often the only clue to the existence of logic errors is the production of wrong solutions, though static analysis may sometimes spot them.

Debugging logic errors[edit]

One of the ways to find this type of error is to put out the program’s variables to a file or on the screen in order to determine the error’s location in code. Although this will not work in all cases, for example when calling the wrong subroutine, it is the easiest way to find the problem if the program uses the incorrect results of a bad mathematical calculation.

Examples[edit]

This example function in C to calculate the average of two numbers contains a logic error. It is missing parentheses in the calculation, so it compiles and runs but does not give the expected answer due to operator precedence (division is evaluated before addition).

float average(float a, float b)
{
    return a + b / 2;  // should be (a + b) / 2
}

See also[edit]

• Syntax error
• Off-by-one error

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

Определение

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

Баги обнаруживаются чаще всего в момент отладки или бета-тестирования. Реже – после итогового релиза готовой программы. Вот несколько вариантов багов:

1. Появляется сообщение об ошибке, но приложение продолжает функционировать.
2. ПО вылетает или зависает. Никаких предупреждений или предпосылок этому не было. Процедура осуществляется неожиданно для пользователя. Возможен вариант, при котором контент перезапускается самостоятельно и непредсказуемо.
3. Одно из событий, описанных ранее, сопровождается отправкой отчетов разработчикам.

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

История происхождения термина

Баг – слово, которое используется разработчиками в качестве сленга. Оно произошло от слова «bug» – «жук». Точно неизвестно, откуда в программировании и IT возник соответствующий термин. Существуют две теории:

1. 9 сентября 1945 года ученые из Гарварда тестировали очередную вычислительную машину. Она называлась Mark II Aiken Relay Calculator. Устройство начало работать с ошибками. Когда его разобрали, то ученые заметили мотылька, застрявшего между реле. Тогда некая Грейс Хоппер назвала произошедший сбой упомянутым термином.
2. Слово «баг» появилось задолго до появления Mark II. Термин использовался Томасом Эдисоном и указывал на мелкие недочеты и трудности. Во время Второй Мировой войны «bugs» называли проблемы с радарной электроникой.

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

Как классифицируют

Ошибки работы программ разделяются по разным факторам. Классификация у рядовых пользователей и разработчиков различается. То, что для первых – «просто программа вылетела» или «глючит», для вторых – огромная головная боль. Но существует и общепринятая классификация ошибок. Пример – по критичности:

1. Серьезные неполадки. Это нарушения работоспособности приложения, которые могут приводить к непредвиденным крупным изменениям.
2. Незначительные ошибки в программах. Чаще всего не оказывают серьезного воздействия на функциональность ПО.
3. Showstopper. Критические проблемы в приложении или аппаратном обеспечении. Приводят к выходу программы из строя почти всегда. Для примера можно взять любое клиент-серверное приложение, в котором не получается авторизоваться через логин и пароль.

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

Также существуют различные виды сбоев в плане частоты проявления: постоянные и «разовые». Вторые встречаются редко, чаще – при определенных настройках и действиях со стороны пользователя. Первые появляются независимо от используемой платформы и выполненных клиентом манипуляций.

Иногда может получиться так, что ошибка возникает только на устройстве конкретного пользователя. В данном случае устранение неполадки требует индивидуального подхода. Иногда – полной замены компьютера. Связано это с тем, что никто не будет редактировать исходный код, когда он «глючит» только у одного пользователя.

Виды

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

Разработчики выделяют следующие типы ошибок по уровню сложности:

1. «Борбаг» – «стабильная» неполадка. Она легко обнаруживается на этапе разработки и компилирования. Иногда – во время тестирования наработкой исходной программы.
2. «Гейзенбаг» – баги с поддержкой изменения свойств, включая зависимость от среды, в которой было запущено приложение. Сюда относят периодические неполадки в программах. Они могут исчезать на некоторое время, но через какой-то промежуток вновь дают о себе знать.
3. «Мандельбаг» – непредвиденные ошибки. Обладают энтропийным поведением. Предсказать, к чему они приведут, практически невозможно.
4. «Шрединбаг» – критические неполадки. Приводят к тому, что злоумышленники могут взломать программу. Данный тип ошибок обнаружить достаточно трудно, потому что они никак себя не проявляют.

Также есть классификация «по критичности». Тут всего два варианта – warning («варнинги») и критические весомые сбои. Первые сопровождаются характерными сообщениями и отчетами для разработчиков. Они не представляют серьезной опасности для работоспособности приложения. При компилировании такие сбои легко исправляются. В отдельных случаях компилятор справляется с этой задачей самостоятельно. А вот критические весомые сбои говорят сами за себя. Они приводят к серьезным нарушениям ПО. Исправляются обычно путем проработки логики и значительных изменений программного кода.

Типы багов

Ошибки в программах бывают:

• логическими;
• синтаксическими;
• взаимодействия;
• компиляционные;
• ресурсные;
• арифметические;
• среды выполнения.

Это – основная классификация сбоев в приложениях и операционных системах. Логические, синтаксические и «среды выполнения» встречаются в разработке чаще остальных. На них будет сделан основной акцент.

Ошибки синтаксиса

Синтаксические баги распространены среди новичков. Они относятся к категории «самых безобидных». С данной категорией ошибок способны справиться компиляторы тех или иных языков. Соответствующие инструменты показывают, где допущена неточность. Остается лишь понять, как исправить ее.

Синтаксические ошибки – ошибки синтаксиса, правил языка. Вот пример в Паскале:

Код написан неверно. Согласно действующим синтаксическим нормам, в Pascal в первой строчке нужно в конце поставить точку с запятой.

Логические

Тут стоит выделить обычные и арифметические типы. Вторые возникают, когда программе при работе необходимо вычислить много переменных, но на каком-то этапе расчетов возникают неполадки или нечто непредвиденное. Пример – получение в результатах «бесконечности».

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

Выше – пример логической ошибки в программе. Тут:

1. Происходит сравнение значения i с 15.
2. На экран выводится сообщение, если I = 15.
3. В заданном цикле i не будет равно 15. Связано это с диапазоном значений – от 1 до 10.

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

Время выполнения

Run-time сбои – это ошибка времени выполнения программы. Встречается даже когда исходный код лишен логических и синтаксических ошибок. Связаны такие неполадки с ходом выполнения программного продукта. Пример – в процессе функционирования ПО был удален файл, считываемый программой. Если игнорировать подобные неполадки, можно столкнуться с аварийным завершением работы контента.

Самый распространенный пример в данной категории – это неожиданное деление на ноль. Предложенный фрагмент кода с точки зрения синтаксиса и логики написан грамотно. Но, если клиент наберет 0, произойдет сбой системы.

Компиляционный тип

Встречается при разработке на языках высокого уровня. Во время преобразований в машинный тип «что-то идет не так». Причиной служат синтаксические ошибки или сбои непосредственно в компиляторе.

Наличие подобных неполадок делает бета-тестирование невозможным. Компиляционные ошибки устраняются при разработке-отладке.

Ресурсные

Ресурсный тип ошибок – это сбои вроде «переполнение буфера» или «нехватка памяти». Тесно связаны с «железом» устройства. Могут быть вызваны действиями пользователя. Пример – запуск «свежих» игр на стареньких компьютерах.

Исправить ситуацию помогают основательные работы над исходным кодом. А именно – полное переписывание программы или «проблемного» фрагмента.

Взаимодействие

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

Исключения и как избежать багов

Исключение – событие, при возникновении которых начинается «неправильное» поведение программы. Механизм, необходимый для стабилизации обработки неполадок независимо от типа ПО, платформ и иных условий. Помогают разрабатывать единые концепции ответа на баги со стороны операционной системы или контента.

Исключения бывают:

1. Программными. Они генерируются приложением или ОС.
2. Аппаратными. Создаются процессором. Пример – обращение к невыделенной памяти.

Исключения нужны для охвата критических багов. Избежать неполадок помогут отладчики на этапе разработки. А еще – своевременное поэтапное тестирование программы.

P. S. Большой выбор курсов по тестированию есть и в Otus. Присутствуют варианты как для продвинутых, так и для начинающих пользователей.

Ошибки в программировании. Примеры ошибок в языке Паскаль

Ошибки в
программировании бывают двух типов:
синтаксические и логические. Синтаксические
ошибки это неправильное написание
ключевых слов и символов языка
программирования. Все виды синтаксических
ошибок могут быть найдены компьютером
в 99 % случаев.

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

Примеры синтаксических
ошибок в языке Паскаль и их исправление:

1)
Не поставлена точка с запятой. После
пуска программы, нажатием клавиш
<Ctrl>+<F9>, в верхней строке экрана
появится написанное красным цветом
сообщение:

Error 85: «;»
expected.

(Ошибка 85: «;»
отсутствует.)

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

2)
В описании переменных не записана
переменная, а в программе она присутствует.
После пуска программы, будет выдано
сообщение:

Error 3: Unknown identifier.

(Ошибка 3: Неизвестный
идентификатор.)

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

3)
Не поставлена точка после оператора
end в конце программы. Сообщение компилятора
будет таким:

Error 10: Unexpected end of
file.

(Ошибка 10: Неправильный
конец файла.),

Курсор
установится на букву «e» в слове
«end». Надо поставить точку и снова
выполнить программу.

Выполнение программы. Ключевые кнопки

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

Для
этого нажимаем клавиши <Ctrl>+<F9>
(удерживая клавишу <Ctrl>, нажать
клавишу <F9>). Эту же операцию можно
выполнить, перейдя в основное меню,
нажав клавишу <F10>, а затем перемещением
указателя выбрать опцию Run и нажать
клавишу <Ввода>.

Теперь надо найти
в новом меню опцию RUN (пуск) и нажать
клавишу <Ввод>.

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

После
завершения прогона (работа программы
часто называется ее прогоном) на экране
вновь появится окно редактора с
текстом программы. Если Вы не успели
разглядеть изображение окна программы,
то нажмите Alt-F5. При этом окно редактора
скроется
и вы сможете увидеть результаты работы
программы. Чтобы вернуть экран в режим
воспроизведения окна редактора, надо
нажать на любую клавишу.

Первые ошибки и их исправление

1.
Не поставлена точка с запятой, например,
после оператора readln(a). После пуска
программы, нажатием клавиш <Ctrl>+<F9>,
в верхней строке экрана появится
написанное красным цветом сообщение:

Error 85: «;»
expected.

(Ошибка 85: «;»
отсутствует.)

Редактор
установит курсор на следующий символ
после пропущенного знака, в нашем
примере на переменную b. После нажатия
любой клавиши, сообщение об ошибке
исчезает и редактор переходит в режим
вставки. Надо подвести курсор к нужному
месту, поставить точку с запятой — “;”
и продолжить работу.

2.
В описании переменных не записана
переменная, а в программе она присутствует,
например переменная c. После пуска
программы, будет выдано сообщение:

Error 3: Unknown identifier.

(Ошибка 3: Неизвестный
идентификатор.)

Курсор
будет установлен на эту переменную, в
нашем примере на переменную c. Надо
исправить ошибку, т.е. записать переменную
c в раздел описаний переменных и продолжить
работу.

3.
Не поставлена точка после оператора
end в конце программы. Сообщение компилятора
будет таким:

Error 10: Unexpected end of
file.

(Ошибка 10: Неправильный
конец файла.),

курсор
установится на букву «e» в слове
«end». Надо поставить точку и снова
выполнить программу.

Помощь
в “PASCAL”.

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

Меню
опции HELP

CONTENTS.
Выводит на экран содержание справочной
службы.

INDEX.
Выводит на экран алфавитный список всех
ссылок справочной службы. Вызывается
из редактора командой Shift-F1.

TOPIC
SEARCH.
Осуществляет поиск в окрестности курсора
зарезервированного слова или имени
стандартной процедуры (функции) и дает
соответствующую справку. Вызывается
из редактора командой Ctrl-F1.

PREVIOUS
TOPIC.
Выводит на экран предыдущее справочное
сообщение. Вызывается из редактора
командой Alt-F1.

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

FILES.
С помощью этой опции Вы можете установить
нужные файлы справочной службы.

COMPILER
DIRECTIVES.
Показывает справку о директивах
компилятора.

RESERVED
WORDS.
Показывает справку о зарезервированных
словах.

STANDARD
UNITS.
Показывает справку о стандартных
модулях.

TURBO
PASCAL
LANGUAGE.
Показывает справку о языке Турбо Паскаль.

ERROR
MESSAGES.
Показывает справку о сообщениях об
ошибках.

ABOUT.
Выводит информацию об авторских правах
и версии Турбо Паскаля.

Лекция №7
Процедуры. Программирование рекурсивных
алгоритмов.

Дедуктивный
метод программирования

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

Итак,
весь творческий процесс можно разбить
(разумеется, чисто условно) на следующие
этапы:

1) основная идея
решения задачи;

2) общая конструкция
программы;

3)
выделение отдельных, элементарных
частей программы;

4)
практическая реализация на языке
программирования этих частей программы;

5)
объединение их в единую программу.

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

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

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

Для
облегчения такой работы и созданы
подпрограммы.

Использование
подпрограмм позволяет:

1)
сделать основную программу более
наглядной и компактной;

2) уменьшить объем
используемой памяти ЭВМ;

3) сократить время
отладки программы.

На
языке Паскаль подпрограммы
бывают двух видов, — это процедуры и
функции.

Процедуры

Рассмотрим
следующий простой пример, с помощью
которого попробуем разобраться в
конструкции процедур на Паскале.

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

Мы
знаем, что числа называются взаимно
простыми, если их наибольший общий
делитель (НОД) равен 1. Значит, для решения
этой задачи нам придется дважды находить
НОД чисел. Если заданы три числа: a, b, c,
то найти НОД(a, b), а затем найти НОД(НОД(a,
b), c).

Дважды
писать операторы для нахождения НОД
нам не хочется, поэтому оформим операторы
для НОД в виде процедуры.

Посмотрите,
как это будет выглядеть в программе:

Program Problem1;

var

a, b, c, k : integer;

{———————————————————————————}

Procedure nod(a, b :
integer; var n : integer);

var

r
: integer;

begin

repeat

r := a mod b;

a := b; b := r

until
b = 0;

n := a

end;

{———————————————————————————}

begin

write(‘Введите
три натуральных числа ‘); readln(a,
b,
c);

nod(a,
b,
k);

a
:= k;
b
:= c;

nod(a,
b,
k);

if
k
= 1 then
writeln(‘Числа
взаимно простые’)

else
writeln(‘Числа не взаимно простые’)

end.

В
разделе описаний, после описания
переменных, записывается заголовок
процедуры: Procedure

Это
слово является служебным и зарезервировано
в Паскале. В одной строке с ним, через
пробел, записывается имя процедуры,
которое должно удовлетворять всем
требованиям, предъявляемым к именам,
основными из которых являются: начинаться
с буквы и не иметь пробелов, т. е.,
требования такие же, как и к имени
программы (имя нашей процедуры — nod):

Procedure
nod(a,
b
: integer;
var
n
: integer);

Далее,
в скобках, записываются имена переменных
и их типы, значения которых будут
вводиться
в процедуру из основной программы, в
нашем случае, их две (a, b) и они имеют тип
integer.

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

После
точки с запятой и зарезервированного
слова var, записываются переменные и их
типы, значения которых будет являться
результатом работы процедуры и выводятся
из нее в основную программу. Такая
переменная в нашем примере одна — n. Она
выведет значение НОД чисел a и b. Ее имя
также может иметь одноименное в основной
программе и это нисколько не отразится
на работе процедуры.

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

Так,
если поставить var перед a и b, то компилятор
будет воспринимать эти переменные как
выходные и вводимые для них значения
воспринимать не будет, и, наоборот, если
var не будет записано перед выходной
переменной, то компилятор воспримет ее
как входную и выводить ее значение в
основную программу не будет.

Дальнейшее
построение процедуры строится также,
как и основная программа на Паскале.

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

В
нашем примере процедура
nod будет такой:

Procedure
nod(a, b : integer; var n : integer);

var

r
: integer;

begin

repeat

r := a mod b;

a := b; b := r

until
b = 0;

n := a

end;

Основная
программа строится обычным образом, но
там, где необходимо найти НОД чисел,
обращается к процедуре. Как?

Для
этого обращаются к ней по имени, а в
скобках записывают фактические значения
входных переменных (в нашем случае для
переменных a и b), а также имена выходных
переменных (в нашем случае k).

Из
приведенного ниже участка программы
видно, что при первом обращении к
процедуре nod определяется НОД чисел a и
b (nod(a, b, k)) и результат запоминается в
переменную k, далее, изменяются значения
переменных a и b
и снова вызывается процедура nod, которая
уже находит НОД чисел k и c и результат
присваивает переменной k.

Вы можете видеть
основную часть программы:

begin

write(‘Введите
три натуральных числа ‘); readln(a, b, c);

nod(a,
b,
k);

a
:= k;
b
:= c;

nod(a,
b,
k);

if
k
= 1 then
writeln(‘Числа
взаимно простые’)

else
writeln(‘Числа не взаимно простые’)

end.

Сделаем
общие выводы для построения и работы
процедур

Процедуры
помещаются в разделе описаний и начинается
зарезервированным (служебным) словом

Procedure

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

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

Выходные
параметры — это те переменные, в которых
получается результат выполнения
процедуры.

Входные
и выходные параметры процедуры называются
формальными
параметрами.

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

После
формальных параметров, описываются
переменные, которые необходимы
непосредственно для работы процедуры.

Это
параметры
процедуры.
Они нужны в ней, как и в любой другой
программе и описываются также. Их имена
должны отличаться от имен входных и
выходных параметров.

Надо
заметить, что процедура может быть
такой, что в ней не будет вообще параметров,
достаточно тех, которые будут введены
из программы.

Описание процедуры
имеет вид:

Procedure <имя>
(<входные параметры> : <их тип>;

var

<выходные
параметры> : <их тип>);

(раздел
описаний)

begin

(раздел
операторов)

end;

Она
помещается в основной программе в
разделе описаний.

По
входным и выходным параметрам процедуры
могут быть следующих типов:

1)
иметь и
входные и выходные параметры:

Procedure <имя>(<входные
параметры> : <их тип>;

var <выходные
параметры> : <их тип>);

Мы только
познакомились с программой такого типа.

2)
иметь входные параметры, но не иметь
выходных:

Procedure <имя>(<входные
параметры> : <их тип>);

3)
иметь выходные
параметры, но не иметь входных:

Procedure <имя>(var
<выходные параметры> : <их тип>);

4)
не иметь ни
входных, ни выходных параметров:

Procedure <имя>;

В
зависимости от этого различаются
процедуры по своей конструкции и
выполняемым функциям.

Далее
следует раздел операторов, который
составляется по тем же правилам, как и
в других программах.

Процедура
описана и после этого начинается основная
программа.

Как происходит
вызов подпрограммы — процедуры?

Обязательно
указывается имя процедуры. В скобках
задаются фактические
значения входных параметров и те
переменные, в которые будут «запоминаться»
выходные значения.

Рассмотрим
пример, где может быть использована
процедура второго типа: имеет входные
параметры, но не имеет выходных.

Пример.
Составить программу, которая устанавливает,
какие числа из заданного промежутка
[a; b] можно представить в виде суммы двух
квадратов целых чисел?

В
этой программе, нам придется проверять
каждое из чисел промежутка [a; b] можно
ли его представить в виде суммы квадратов
двух чисел, поэтому было бы разумно
разработать процедуру, которая бы
проверяла одно число и затем обращаться
к ней из основной программы для проверки
каждого числа из промежутка.

Процедуру
составим по следующему способу. Пусть
задано число n. Нам необходимо найти
такие два числа a и b, чтобы сумма их
квадратов была равна n, т.е. решить в
целых числах уравнение:

Возникает
естественное желание испытывать
натуральные числа от 1 и до …? А вот до
какого значения неизвестно. Если их
брать до числа n, то это будет слишком
много лишней и бесполезной работы.

Чтобы
выяснить этот вопрос, можно организовать
цикл, в
котором проверять сколько чисел a надо,
чтобы выполнялось неравенство:
Здесь, в качестве b взято наименьшее
натуральное число 1. Организовав такой
цикл, и подсчитав, сколько чисел a
потребуется, мы узнаем сколько чисел
надо просматривать, чтобы найти решение
уравнения.

Этот цикл может
быть таким:

a
:= 1; k := 1;

while
a*a + 1<=n do

begin

k
:= k + 1;

a
:= a + 1

end;

Теперь ясно, что
для испытания чисел, следует устроить
цикл от 1 до k:

for a := 1 to k do

Второй
цикл должен
быть для значений b. Но если его организовать
тоже от 1 до k, тогда могут повторяться
дважды одинаковые значения, только на
разных местах, например, для числа 20
могут быть выданы следующие значения:

2²
+ 4²
= 20 и 4²
+ 2²
= 20.

Чтобы
избежать повторения чисел, цикл для
чисел b можно организовать либо от 1 до
a, либо от k до а.

Нами выбран первый
вариант.

Процедура

Procedure to_square(n :
integer);

label
1;

var

a, b, k : integer;

begin

a := 1; k := 1;

while a*a + 1<=n
do

begin

k := k + 1;

a := a + 1

end;

for a := 1 to k do

for b := 1 to a do

if a*a + b*b =
n

then

begin

writeln(n,
‘=’, a, ‘*’, a,’ +’, b, ‘*’, b); goto 1

end;

1: end;

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

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

Программа

Program Problem2;

var

a, b, i : integer;

{———————————————————————————}

Procedure to_square(n :
integer);

label 1;

var

a,
b, k : integer;

begin

a := 1; k := 1;

while a*a + 1 <=
n do

begin

k := k + 1;

a := a + 1

end;

for a := 1 to k do

for b := 1 to a
do

if a*a + b*b =
n

then

begin

writeln(n,
‘=’, a, ‘*’, a, ‘+’, b,’*’, b); goto 1

end;

1: end;

{———————————————————————————}

begin

write(‘Введите
начало
промежутка
‘); readln(a);

write(‘Введите конец
промежутка ‘); readln(b);

write(‘Числа,
которые можно представить в виде суммы
‘);

writeln(‘квадратов
следующих
чисел’);

for i := a to b do
to_square(i);

end.