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

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

2. Синтаксические. Когда ошибки в написании кода, например, ошибочно указано имя функции, переменной, или передано в функцию недостаточное количество аргументов, не проставлен знак пунктуации в необходимом месте. Работать такая программа определенно не будет.

3. Ошибки в процессе выполнения. Когда ошибка возникает во время выполнения программы, например, нехватка системных ресурсов (памяти), или зацикленность программы.

5 Нравится Комментировать
Лучший ответ выбран модератором

Другие ответы (5)

• Букет
• 3. Исследователь (245)
• 5 лет

Пользователь

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

Курс Excel_Базовый — Урок №16 Виды ошибок. Исправление ошибок

В нашем случае это ошибки совершенные в ходе написания структуры кода. Следующее нарушение – ошибки времени выполнения (Runtime errors). Такие неисправности возникают уже в ходе работы программы. Причиной чаще всего являются неверные исходные данные.Их лучше конечно заметить и решить до его запуска. И последний тип – логические ошибки.

По-другому их еще называют – баг. Он зачастую приводит к некорректной работе программы. Они могут появляться в компиляторах и интерпретаторах.

4 Нравится Комментировать

• Mega
• 9. Мыслитель (3165)
• 4 года

Пользователь

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

1 Нравится Комментировать

• Юра
• 22. Сверхразум (72846)
• 1 год

Пользователь

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

1 Нравится Комментировать

• Дэнчик
• 17. Гений (13091)
• 1 год

Пользователь

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

2 Нравится Комментировать

• Витя Оболенский
• 11. Философ (5965)
• 1 год

Пользователь

Семантические и синтаксические. При втором типе программа не выполнится вообще

Источник: nolvoprosov.ru

Обработка ошибок

Аннотация: Попытка классификации ошибок. Сообщение об ошибке с помощью возвращаемого значения. Исключительные ситуации. Обработка исключительных ситуаций, операторы try и catch.

Три типа ошибок программирования в любом языке. Типичные ошибки программистов.

Виды ошибок

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

Ошибки компиляции пропустим:пока все они не исправлены, программа не готова, и запустить ее нельзя. Здесь мы будем рассматривать только ошибки , происходящие во время выполнения программы.

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

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

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

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

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

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

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

Ну и решающими качествами, позволяющими уменьшить количество ошибок , являются внимательность, аккуратность и опыт .

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

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

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

Возвращаемое значение как признак ошибки

Простейший способ сообщения об ошибках предполагает использование возвращаемого значения функции или метода. Функция сохранения объекта в базе данных может возвращать логическое значение : true в случае успешного сохранения, false – в случае ошибки .

class Database < public: bool SaveObject(const Object >;

Соответственно, вызов метода должен выглядеть так:

if (database.SaveObject(my_obj) == false )< //обработка ошибки >

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

int main() < if (fun1()==false ) //обработка ошибки return 1; >bool fun1() < if (fun2()==false ) return false ; return true ; >bool fun2()

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

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

Распространенным решением является дополнительный атрибут объекта – флаг, отражающий состояние объекта. Предположим, конструктор класса Database должен соединиться с сервером базы данных .

class Database < public : Database(const char *serverName); . bool Ok(void) const ; private : bool okFlag; >; Database::Database(const char*serverName) < if (connect(serverName)==true ) okFlag =true ; else okFlag =false ; >int main() < Database database(«db-server»); if (!database.Ok())< cerr return 1; >

Лучше вместо метода Ok , возвращающего значение флага okFlag , переопределить операцию ! ( отрицание ).

class Database < public : bool operator !()const ; >;

Тогда проверка успешности соединения с базой данных будет выглядеть так:

if (!database)

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

class Database

и тогда отпадает необходимость в операции ! или методе Ok() .

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

Источник: intuit.ru

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

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

Что-то удается вычислить при автоматическом или бета-тестировании.

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

Работа с необъявленными переменными

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

1. Если синтаксис ЯП требует жесткого объявления и типизации переменных, интерпретатор «вылетит» из процесса компиляции с указанием ошибки. Это хороший случай, так как вы, скорей всего, быстро поймете, в чем дело, ведь необъявленный объект будет присутствовать в указанной строке ошибки.
2. При использовании языков с менее жесткой структурой, переменная «объявится» автоматически с момента ее появления в коде. Казалось бы, это удобно. На самом деле, отладка в случае подобной ошибки значительно усложняется. В вашу переменную может быть записано любое значение, в том числе, не предусмотренного программой типа. В результате код будет «вылетать» в строке с попыткой выполнить какие-то вычисления или другой вид обработки с участием этой переменной, что усложнит поиск проблемы. В худшем случае, ошибка будет неявной, логической, т.е. программа будет работать, но выдаст неверный результат.

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

Инициализация переменных без начального значения

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

Приведем пример такого кода:

В результате его исполнения вы можете ввести, например, числа 2 и 5, а в качестве результата получить 2384.

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

Необъявленные функции

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

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

Переполнение типа

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

Приведем пример на C++:

[code]A = B + C;
char* G = new char[A];[/code]

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

Но если значения B и C будут большими, их сумма «не поместится» в объем памяти, который занимает A. В результате такого переполнения вместо ожидаемого положительного значения, в переменной A окажется отрицательное число. И на строке выделения памяти для G программа покажет ошибку.

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

Переполнение буфера

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

Самый простой пример подобной проблемы можно описать так: в строковую переменную, которая может вмещать максимум 255 символов, записывают текст большего размера. Если последние из символов, которые уже не вмещаются в выделенный стек памяти, компилятор «прочитывает» как дополнительные адреса ячеек памяти, он обращается к ним. И готов записывать в эту область памяти «излишки» информации. Этим пользуются «черви», которые закидывают в переменную «мусорную информацию», следом за которой идет вредоносный код, который программа «дисциплинированно» размещает в памяти компьютера.

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

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

Ошибки в оценке границ массива

Бытует мнение, что такую ошибку можно допустить только в C или C++. На самом деле, обращение к несуществующему элементу массива возможно в Python, Java и многих других языках. Суть проблемы заключается в том, что программист по причине невнимательности или из-за ошибки в расчетах обращается к элементу массива с несуществующим номером.

Самый просто пример:

1. Вы определили массив из 10 элементов.
2. Нумерация в массиве начинается с нуля, т.е. существуют номера с 0 до 9.
3. Вы забываете об этой особенности массива и обращаетесь к элементу с индексом 10.

При этом программа обращается к неиспользуемой области памяти, присваивает это случайное значение элементу с индексом 10. Результат обработки «мусорной» информации, само собой, непредсказуем.

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

«Забытые» ограничения ресурсов

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

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

Аккуратно относитесь к ограничителям массивов, проверяйте базы данные при слиянии, а при прямом обращении к ОЗУ обязательно указывайте граничные значения.

Обращение к освобожденной памяти

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

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

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

Инъекции SQL и команд ОС

Эти два типа инъекций на самом деле являются хакерскими атаками, которые оканчиваются доступом злоумышленника либо к базам данных (SQL), либо к root-доступу на компьютере пользователя.

Причины SQL-инъекций – низкий уровень защиты сайта. Чаще всего, их проводят через отправку сообщений от пользователей (форма обратной связи, добавление записи на форум, обращение в чат и т.д.). Если «дыра» в безопасности не закрыта, злоумышленник отправляет через эти формы вредоносный код, сервер начинает его исполнять. И хакер получает доступ ко всем базам данных.

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

Рискованные алгоритмы

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

С первым случаем все понятно. Защита данных – не та область, где стоит полагаться только на свои, довольно скромные возможности. Пример второго случая – использование алгоритма хэштегирования SHA-1. Если вы воспользуетесь поиском, то очень быстро узнаете, что этот алгоритм уже устарел, в нем найдено множество уязвимостей, под которые написан не один вирус. А потому лучше пользоваться SHA-2 или SHA-3.

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

Источник: techrocks.ru