Процесс отладки программы. Отладка и тестирование программы Процесс отладки программы

Понятия «отладка», «отладка программы». Процесс отладки. Виды (методика) отладок, приемы отладки.

После того как процесс проектирования формы завершен и программный код написан, необходимо откомпилировать программу. В процессе компиляции следует исправить не только ошибки, но и замечания. Большинство ошибок имеют синтаксический характер. Часто сообщения о такой ошибке возникают еще на стадии написания программного кода. Если ошибка не исправлена пользователем, то текст оператора будет выделен красным цветом. Если ошибки при компиляции исправлены, то при запуске приложения вовсе необязательно, что не возникнет новых ошибок. Это могут быть логические ошибки. Могут появиться ошибки при определенных данных: деление на 0, переполнение, извлечение квадратного корня из отрицательного числа, отсутствие инициализации в начале вычислений, открытие несуществующего файла и др.
При появлении исключительных ситуаций на этапе выполнения приложений компилятор сообщает об этом пользователю в диалоговом окне.
При прерывании работы приложения строка будет отмечена желтым цветом, если диалоговое окно будет закрыто при нажатии кнопки Debug - Отладка. Если сообщение об ошибке было закрыто кнопкой End - Закончить, то будет отмечен заголовок процедуры, в которой найдена ошибка.

Отладка программы

Отладка, как мы уже говорили, бывает двух видов:

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

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

Отладка - это процесс локализации и исправления ошибок в программе.

Принципы отладки

Принципы локализации ошибок:

· Большинство ошибок обнаруживается вообще без запуска программы - просто внимательным просматриванием текста.

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

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

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

Принципы исправления ошибок еще больше похожи на законы Мерфи:

· Там, где найдена одна ошибка, возможно, есть и другие.

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

· Наша задача - найти саму ошибку, а не ее симптом.

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

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

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

Методы отладки.

1.Силовые методы

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

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

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

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

Суммируя свойства силовых методов, получаем практические советы:

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

o использовать отладочную печать в небольших количества и "по делу";

o оставить дамп памяти на самый крайний случай.

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

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

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

5.Метод тестирования.

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

· Метод дедукции.
Данный метод позволяет на основе некоторых общих теорий или предпосылок, используя операторы исключения или уточнения, прийти к определенному заключению (обнаружить место ошибки). Чтобы сделать заключение мы должны просмотреть всю имеющуюся в нашем распоряжении информацию: все результаты всех тестов обо всех ошибках. Выдвинутые гипотезы поочередно исключаются из рассмотрения.

· Прослеживание логики в обратном порядке.
Метод локализации для небольших ошибок. Отладка начинается в точке программы, где был обнаружен некоторый результат. Для этой точки на основании полученного результата следует установить, какими должны быть значения переменных. Мысленно выполняя из данной точки программы в обратном порядке и опять рассуждая примерно так: "Если бы в этой точке состояние программы было таким, то в другой точке должно быть следующее состояние", можно достаточно быстро и точно локализовать ошибку, т.е. найти место в программе между точкой, где состояние программы соответствовало ожидаемому и точкой, в которой состояние программы отличалось от ожидаемого.

Автоматизированные средства отладки программ.

Стандартные возможности отладчика. Контроль правильности написанной программы (этапы).

Средства отладки

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

1) Аварийная печать - вывод сообщений о ненормальном завершении отдельных блоков и всей программы в целом.

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

3) Непосредственное слежение:

· арифметическое (за тем, чему равны, когда и как изменяются выбранные переменные),

· логическое (когда и как выполняется выбранная последовательность операторов),

· контроль выхода индексов за допустимые пределы,

· отслеживание обращений к переменным,

· отслеживание обращений к подпрограммам,

· проверка значений индексов элементов массивов и т.д.

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

· просмотреть текущие значения переменных, состояние памяти, участок алгоритма, где произошел сбой;

· прервать выполнение программы;

· внести в программу изменения и повторно запустить ее (в компиляторных средах для этого потребуется перекомпилировать код, в интерпретаторных выполнение можно продолжить прямо с измененного оператора).

Автономное тестирование модуля целесообразно осуществлять в четыре последовательно выполняемых шага.

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

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

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

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

Советы отладчику

1) Проверяйте тщательнее: ошибка скорее всего находится не в том месте, в котором кажется.

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

3) Тщательнее следить за объявлениями констант, типов и переменных, входными данными.

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

5) Анализировать код, начиная с самых простых вариантов. Чаще всего встречаются ошибки:

· значения входных аргументов принимаются не в том порядке,

· переменная не проинициализирована,

· при повторном прохождении модуля, перемен ная повторно не инициализируется,

· вместо предполагаемого полного копирования структуры данных, копируется только верхний уровень (например, вместо создания новой динамической переменной и присваивания ей нужного значения, адрес тупо копируется из уже существующей переменной),

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

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

7) Ошибка, скорее всего окажется вашей и будет находиться в тексте программы. Гораздо реже она оказывается:

· в компиляторе,

· операционной системе,

· аппаратной части,

· электропроводке в здании и т.д.

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

8) Убедитесь, что исходный текст программы соответствует скомпилированному объектному коду (текст может быть изменен, а запускаемый модуль, который вы тестируете - скомпилирован еще из старого варианта).

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

10) Старайтесь не жалеть времени, чтобы уясненить причину ошибки. Это поможет вам:

· исправить программу,

· обнаружить другие ошибки того же типа,

· не делать их в дальнейшем.

11) Если вы уже знаете симптомы ошибки, иногда полезно не исправлять ее сразу, а на фоне известного поведения программы поискать другие ляпы.

12) Самые труднообнаруживаемые ошибки - наведенные, то есть те, что были внесены в код при исправлении других.

оверкой называется проверка результатов тестирования самой тестируемой программой

Отладка программы является итеративным процессом обнаружения и исправления ошибок и обычно требует последовательного выполнения четырех этапов:

выявления ошибки;

локализации ошибки в тексте программы;

установления причины ошибки;

исправления ошибки.

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

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

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

1. Причины и типы ошибок

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

синтаксические ошибки;

семантические ошибки;

логические ошибки.

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

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

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

Ошибки первого типа легко выявляются самим компилятором. Обычно устранение синтаксических ошибок не вызывает особых трудностей. Более сложно выявить ошибки второго и особенно третьего типа. Для обнаружения и устранения ошибок второго и третьего типа обычно применяют специальные способы и средства отладки программ. Выявлению ошибок второго типа часто помогает использование контролирующих режимов компиляции с проверкой допустимых значений тех или иных параметров (границ индексов элементов массивов, значений переменных типа диапазона, ситуаций переполнения, ошибок ввода-вывода). Устанавливаются эти режимы с помощью ключей компилятора , задаваемых либо в программе, либо в меню Project/Options/Compiler среды Delphi, либо в меню Options/Compiler Турбо-среды.

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

Ошибки выполнения

Другой тип ошибок - ошибки выполнения программы или семантические ошибки. Они встречаются, когда пользователь компилирует синтаксически корректную программу, которая пытается сделать что-нибудь запрещенное во время ее выполнения, например, открывает несуществующий файл для ввода или производит деление на 0.

Логические ошибки

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

Существуют две взаимодополняющие технологии отладки.

Вот что пишут об этих двух подходах к отладке программы Брайан Керниган и Роб Пайк:

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

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

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

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

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

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

Отладка с использованием отладчика в программных средах:

Pascal

Интегрированный отладчик Turbo Pascal

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

Интегрированный отладчик Turbo Pascal имеет все описанные выше возможности и даже более того. Он представляет собой встроенную часть интегрированной усовершенствованной среды Turbo Pascal (IDE): для использования предлагаются две основные функции меню (Run, Debug), а также некоторые клавиши для команд отладчика.

Visual Studio

Описание технологии отладки на примере Visual Studio C#

В данном разделе я попробую описать процесс отладки программы, написанной в среде «Visual Studio C# 2008 Express Edition» . Все ошибки в коде программы, которые я сам же буду находить сделаны специально.

Цель: Разработать и отладить программу «АйСчитайка», которая будет производить поиск корней квадратного уравнения.

Разработка:

1)создаём новый проект

2)пишем пользовательский интерфейс

3)пишем сам код программы.

Спустя 10 минут я получил:

{ integer a, b, c; X11.Visible = false; X22.Visible = false; XX.Visible = false; xx1.Visible = false; xx1.Visible = false; xx2.Visible = false; neet.Visible = false; primer.Visible = false; a = Convert.ToInt32(aa.Value); b = Convert.ToInt32(bb.Value); c = Convert.ToInt32(cc.Value) double d = b * b + 4 * a * c; if d > 0 { X11.Visible = true; X22.Visible = true; double x1 = (b + Math.Sqrt(d)) / 2 * a; double x2 = (b - Math.Sqrt(d)) / 2 * a; xx1.Visible = true; xx2.Visible = true; xx1.Text = x1.ToString(); xx2.Text = x2.ToString(); } if (d < 0) { neet.Visible = true; neet.Text = "нет корней" } if (d == 0) { XX.Visible = true; neet.Visible = true; double x = (-b / 2 * a); neet.Text = x.ToString(); } primer.Text = a + "X^2+" + b + "X+" + c + "=0"; primer.Visible = true; }

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

После щелчка по ошибке в «списке ошибок» курсор будет перенесен на строчку где предполагается синтаксическая ошибка.

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

При попытке расчёта, с входными данными 2, 4, -6 мы получаем ответ «нет корней». Это неправильный ответ . Придётся искать логические ошибки . В этом нам и поможет «отладчик» .

Рассмотри наш проект. И заметим строчки где выполняются вычисления. Это строчки:

1)double d = b * b + 4 * a * c;

2)double x1 = (b + Math.Sqrt(d)) / 2 * a;

3)double x2 = (b - Math.Sqrt(d)) / 2 * a;

4)double x = (-b / 2 * a);

Выделим СЛЕДУЮЩУЮ строчку после этих строчек, и нажмем клавишу F9 . Это клавиша для создания «точки остановки компиляции» . Если выполнение программы дойдёт до данной точки, то компиляция остановится, и вы уведите значения всех переменных, которые были в момент остановки компиляции. Снять «точку» можно просто выполнив щелчек левой кнопкой мыши.

Начнём процесс компиляции. Когда процесс дойдёт до «точки остановки», мы увидим значения переменных.

После изменений. Мы заново запускаем программу. И получаем уже корректное значение переменной d. Затем с помощью кнопки f10 , мы выполняем программу дальше, до следующих точек остановки.

Но наша программа по прежнему не корректно работает. Мы аналогичным способом находим еще 2 ошибки.

double x1 = (b + Math.Sqrt(d)) / 2 * a; заменяем на double x1 = (-b + Math.Sqrt(d)) / 2 * a;

double x2 = (b - Math.Sqrt(d)) / 2 * a; заменяем на double x2 = (-b - Math.Sqrt(d)) / 2 * a;

После исправления всех ошибок, программа выдаёт верный ответ.

Мы «прогоняем» через программу как можно больше тестов. Чтобы рассмотреть все возможные случаи.

ОТЛАДКА ОКОНЧЕНА! ПРОГРАММА РАБОТАЕТ!

Так должен выглядеть отлаженный код:

{ int a, b, c; X11.Visible = false; X22.Visible = false; XX.Visible = false; xx1.Visible = false; xx1.Visible = false; xx2.Visible = false; neet.Visible = false; primer.Visible = false; a = Convert.ToInt32(aa.Value); b = Convert.ToInt32(bb.Value); c = Convert.ToInt32(cc.Value); double d = b * b - 4 * a * c; if (d > 0) { X11.Visible = true; X22.Visible = true; double x1 = (-b + Math.Sqrt(d)) / 2 * a; double x2 = (-b - Math.Sqrt(d)) / 2 * a; xx1.Visible = true; xx2.Visible = true; xx1.Text = x1.ToString(); xx2.Text = x2.ToString(); } if (d < 0) { neet.Visible = true; neet.Text = "нет корней"; } if (d == 0) { XX.Visible = true; neet.Visible = true; double x = (-b / 2 * a); neet.Text = x.ToString(); } primer.Text = a + "X^2+" + b + "X+" + c + "=0"; primer.Visible = true; }

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

Тщательнее тестировать ваш код . Необходимо делать как можно более сложные вычисления, нестандартные.

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

Вывод отладочной информации. Проверяйте значение КАЖДОЙ переменной! Каждого значения, возвращаемого функцией! В файл записывается пустая строка? Проверяйте составляющие этой строки на каждом этапе ее создания и выводите на экран! Убедились, что на экран выводится? Тренируйтесь писать в файл, на тестовой строке! Забитой прямо в код! Уменьшайте количество неизвестных!

Оптимизировать код. Не стоит заставлять компьютер пересчитывать 100 мл. элементов массива.

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

Не волноваться, не торопится.

Заключение

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

Отладка - единственный и самый мощный способ найти ошибку в программе.

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

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

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

Учитывая разнообразие источников ошибок, при составлении плана тестирования классифицируют ошибки на два типа: 1 – синтаксические; 2 – семантические (смысловые).

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

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

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

В план тестирования обычно входят следующие этапы:

1. Сравнение программы со схемой алгоритма.
2. Визуальный контроль программы на экране дисплея или визуальное изучение распечатки программы и сравнение ее с оригиналом на программном бланке. Первые два этапа тестирования способны устранить больше количество ошибок, как синтаксических (что не так важно), так и семантических (что очень важно, так как позволяет исключить их трудоемкий поиск в процессе дальнейшей отладки).
3. Трансляция программы на машинных язык. На этом этапе выявляются синтаксические ошибки. Компиляторы с языков Си, Паскаль выдают диагностическое сообщение о синтаксических ошибках в листинге программы (листингом называется выходной документ транслятора, сопровождающий оттранслированную программу на машинном языке – объектный модуль).
4. Редактирование внешних связей и компоновка программы. На этапе редактирования внешних связей программных модуле программа-редактор внешних связей, или компоновщик задач, обнаруживает такие синтаксические ошибки, как несоответствие числа параметров в описании подпрограммы и обращении к ней, вызов несуществующей стандартной программы. например, 51 H вместо 51 N, различные длины общего блока памяти в вызывающем и вызываемом модуле и ряд других ошибок.
5. Выполнение программы. После устранения обнаруженных транслятором и редактором внешних связей (компоновщиком задач) синтаксических ошибок переходят к следующему этапу – выполнению программы на ЭВМ на машинном языке: программа загружается в оперативную память, в соответствие с программой вводятся исходные данные и начинается счет. Проявление ошибки в процессе вода исходных данных или в процессе счета приводит к прерыванию счета и выдаче диагностического сообщения рабочей программы. Проявление ошибки дает повод для выполнения отладочных действий; отсутствие же сообщений об ошибках не означает их отсутствия в программе. План тестирования включает при этом проверку правильности полученных результатов для каких-либо допустимых значений исходных данных.
6. Тестирование программы. Если программа выполняется успешно, желательно завершить ее испытания тестированием при задании исходных данных, принимающих предельные для программы значения. а также выходящие за допустимые пределы значения на входе.

Контрольные примеры (тесты) – это специально подобранные задачи, результаты которых заранее известны или могут быть определены без существенных затрат.

Наиболее простые способы получения тестов:

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