На каком этапе обнаруживаются ошибки в алгоритме программы

Главная / Программирование /
Язык программирования C++ / Тест 16

Какие ключевые слова используются для создания и обработки исключительных ситуаций?

Функция вычисляет произведение двух чисел. Исходные данные вводятся с клавиатуры. Какие проверки целесообразно ввести в программе?

Сколько блоков catch может быть после блока try?

Возможно ли использовать механизм исключительных ситуаций в деструкторах

На каком этапе обнаруживаются ошибки в алгоритме программы?

Если заданы классы
 class A {... } A1;
class B : public A { ... } B1;
class C : public A { ... } C1;
то что будет выведено при выполнении оператора
throw (C1);
а обработка исключительной ситуации записана
catch (B& b) { cout << 1; }
catch (C& c) { cout << 2; }
catch (A& a) { cout << 3; }
catch (...) { cout << 4; }

Если заданы классы
class A {... } A1;
class B : public A { ... } B1;
class C : public A { ... } C1;
то что будет выведено при выполнении оператора
throw (A1);
а обработка исключительной ситуации записана
catch (B& b) { cout << 1; }
catch (C& c) { cout << 2; }
catch (A& a) { cout << 3; }
catch (...) { cout << 4; }

Если заданы классы
class A {... } A1;
class B : public A { ... } B1;
class C : public B { ... } C1;
то что будет выведено при выполнении оператора
throw (C1);
а обработка исключительной ситуации записана
catch (B& b) { cout << 1; }
catch (C& c) { cout << 2; }
catch (A& a) { cout << 3; }
catch (...) { cout << 4; }

Если в конструкторе класса
 class  A {
 public:
    A() { ptr = new char[size];
         Init(); }
    ~A() { if (ptr) delete[] ptr; }
    char* ptr; };
 произойдет исключительная ситуация, будет ли потеряна память при откате по стеку?

Оператор throw без аргументов

Блок try catch

Об ошибке в конструкторе класса может сигнализировать:

Отметьте, какие возможности языка Си++ помогают предупреждать ошибки:

Отметьте те средства языка Си++, которые относятся к диагностике ошибок

Что может быть аргументом оператора throw?

Какие требования предъявляются к классу исключительных ситуаций?

Что происходит при попытке выполнить оператор return внутри блока catch?

Что будет на экране после выполнения программы

#include <iostream.h>
short x = 4, i = 0;
void fun1()
{  if (i == 0) throw 2; }
int fun2()
{ --x; fun1();  x++; return x; }
int main()
{ try
  { fun2(); }
     catch (int)
  { cout << "Exception "; }
  cout << x << " " << i;  
}
    

Что будет на экране после выполнения программы

#include <iostream.h>
short x = 4, i = 0;
void fun1()
{  if (i == 5) throw 2; }
void fun2()
{ --x; fun1();  x++; }
int main()
{ try
  { fun2(); }
   catch (int)
  { cout << "Exception "; }
  cout << x << " " << i;
}

Что будет на экране после выполнения программы

#include <iostream.h>
short x = 4, i = 0;
void fun1()
{ double p=2;
   if (!i) throw p; }
void fun2()
{ --x; fun1();  x++; }
int main()
{ try
  { fun2(); }
    catch (double)
   { cout << "Exception "; }
  cout << x << " " << i;  
}

Какой результат будет у следующего выражения?
    
    int main()
    { try
      { 
         try
         { 
            try {  throw 1; }
            catch (int) { cout << "Exception 1"; }
         }
         catch (int) { cout << "Exception 2"; }
      }
      catch (int){ cout << "Exception 3"; }  
      return 0;
    }
    

Какой результат будет у следующего выражения?
    
    int main()
    { 
      try
      { 
         try
         { 
            try{  throw 1; }
           catch (float) { cout << "Exception 1"; }
         }
         catch (int){ cout << "Exception 2"; }
      }
      catch (int){ cout << "Exception 3"; } 
     return 0; 
    }
    

Что будет выведено на экран после выполнения программы?
    
    int main()
    { 
       try{ 
            try
            {  throw 3.14; }
           catch (int) { cout << "Exception 1"; }
         }
       catch (...)
         { cout << "Exception 2"; }
       return 0;
      
    }
    

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

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

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

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

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

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

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

1. Программирование

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

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

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

1. Компиляция

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

При
написании программ на Delphi
нужно опасаться трех типов дефектов:

• синтаксических ошибок, которые часто
  бывают опечатками;

• ошибок
  выполнения,
  к которым относятся любые ошибки,
  появляющиеся во время исполнения
  программы;

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

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

Можно
дать Delphi
команду проверить синтаксис программы
двумя способами.
Первый способ — проверить только
синтаксические ошибки, при этом
Delphi
компилирует каждый модуль проекта и
остановится на найденной
ошибке. Второй путь — запустить
компилятор. Этот метод иногда лучше,
чем первый, поскольку он заставляет
Delphi
не только компилировать программу,
но и компоновать ее. Если программа не
имеет синтаксических ошибок,
нажатие кнопки Run
запустит программу на выполнение. Если
один из указанных
методов обнаружит ошибки, Delphi
покажет в статусной строке сообщение
об ошибке и установит указатель вставки
в редакторе кода на место, явившееся
причиной ошибки.

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

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

1. Отладка

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

• контроль правильности
  программы;

• локализация ошибок;

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

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

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

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

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

Использование
отладчика Delphi
просто:
компилируя программу и запуская ее из
среды
Delphi,
уже используется встроенный отладчик.
90% проблем решается 10% возможностей
программного
обеспечения.
Delphi
создает компилированные исполняемые
модули. Поэтому программы
работают очень быстро — слишком быстро,
чтобы видеть код во время
его выполнения. Delphi
обладает большим количеством средств,
которые позволяют
проследить выполнение программы и
узнать статус программы в любой
момент времени.

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

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

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

При
пошаговом прохождении программы в
отладчике иногда необходимо знать,
что содержится в различных переменных.
Для этого можно использовать окно
просмотра переменных WatchList,
которое предоставляет возможность
пассивно просматривать содержимое
одной или нескольких переменных,
или диалоговое окно Evaluate/Modify,
позволяющее работать
только
с одной переменной (в нем можно не только
просмотреть, но и изменить
ее
содержимое). Для
просмотра значения переменной используется
команда Run/AddWatch
или
можно установить указатель мыши
на переменную в окне редактирования,
щелкнуть
правой
кнопкой мыши и выбрать из контекстного
меню команду Add
Watch
at
Cursor.
После этого появится диалоговое окно
Watch
Properties.
Необходимо ввести имя переменной в поле
Expression
(если оно не появилось там автоматически).
Можно просматривать значения
не только переменных, но и выражений
типа x*(y+z).
Единственное ограничение
— выражение не может содержать вызовов
функций, поскольку это
может
вызвать побочный эффект, связанный с
незапланированным вызовом
функции.
Допускается
также просмотр значений записей, массивов
и других
структурированных
элементов. Поле
Repeat
Count
используется в том случае, если есть
большой массив, и нужно
просмотреть его часть.

1. Тестирование

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

1. Оформление программы

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

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

1. Отчет о работе

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

1. Модернизация

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

На рис. 2.1.10 графически
представлен процесс решения задачи на
ЭВМ.

1. ПОСТАНОВКА

2. ПРОЕКТИРОВАНИЕ

2’. ПЛАН ОТЛАДКИ

3. АЛГОРИТМИЗАЦИЯ

3’. ВЫБОР
ОСНОВНЫХ СРЕДСТВ ОТЛАДКИ

4. ПРОГРАММИРОВАНИЕ

5. КОМПИЛЯЦИЯ

5’. ИСПРАВЛЕНИЕ
СИНТАКСИЧЕСКИХ ОШИБОК

6. ОТЛАДКА

6.1 КОНТРОЛЬ

6.2 ЛОКАЛИЗАЦИЯ

6.3 ИСПРАВЛЕНИЕ
СЕМАНТИЧЕСКИХ ОШИБОК

7.
ТЕСТИРОВАНИЕ

7. ТЕСТИРОВАНИЕ

8. ОФОРМЛЕНИЕ

9. ОТЧЕТ О РАБОТЕ

10. МОДЕРНИЗАЦИЯ

Рис. 2.1.10 Этапы решения задачи на
ЭВМ.

Этапы
1 и 2 можно назвать постановочными, 3 — 5
— реализующими, 6 — отладочным, 8, 9, 10 —
заключительными. Первые 3 этапа проводятся
без использования ЭВМ (или ее внешних
устройств), последние (кроме этапа 9 и,
может быть, — с ее использованием.

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

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

1. Тестирование

1. Необходимость
   тестирования программных продуктов

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

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

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

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

1. Отладка
   и общие принципы тестирования

Одним из самых сложных
и трудоемких этапов технологического
процесса разработки программ является
их тестирование и отладка. Как известно,
при создании типичного программного
проекта около 50% общего времени и более
50% общей стоимости расходуется на
проверку (тестирование) разрабатываемой
системы и ее отладку.

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

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

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

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

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

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

Существует два
основных подхода к тестированию:

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

2. Тестирование
программы как “белого ящика”.
Стратегия белого ящика, или стратегия
тестирования, управляемого логикой
программы, позволяет использовать
внутреннюю структуру программы. В этом
случае программист получает тестовые
данные путем анализа логики программы.

Также существует 3
основных способа тестирования:
алгоритмическое, аналитическое и
содержательное.

Соседние файлы в папке ol

• #

  16.04.201373 б10readme.txt

• #
• #
• #
• #

Отладка программы — один их самых сложных этапов разработки программного обеспечения, требующий глубокого знания:

•специфики управления используемыми техническими средствами,

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

•среды и языка программирования,

•реализуемых процессов,

•природы и специфики различных ошибок,

•методик отладки и соответствующих программных средств. 

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

Вцелом сложность отладки обусловлена следующими причинами:

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

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

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

•отсутствуют четко сформулированные методики отладки.

Всоответствии с этапом обработки, на котором проявляются ошибки, различают (рис. 10.1):

    синтаксические ошибки — ошибки, фиксируемые компилятором (транслятором, интерпретатором) при выполнении синтаксического и частично семантического анализа программы; ошибки компоновки — ошибки, обнаруженные компоновщиком (редактором связей) при объединении модулей программы;

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

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

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

if (c = n) x = 0; /* в данном случае не проверятся равенство с и n, а выполняется присваивание с значения n, после чего результат операции сравнивается с нулем, если программист хотел выполнить не присваивание, а сравнение, то эта ошибка будет обнаружена только на этапе выполнения при получении результатов, отличающихся от ожидаемых */ 

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

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

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

• появление сообщения об ошибке, зафиксированной схемами контроля выполнения машинных команд, например, переполнении разрядной сетки, ситуации «деление на ноль», нарушении адресации и т. п.;

•появление сообщения об ошибке, обнаруженной операционной системой, например, нарушении защиты памяти, попытке записи на устройства, защищенные от записи, отсутствии файла с заданным именем и т. п.;

•«зависание» компьютера, как простое, когда удается завершить программу без перезагрузки операционной системы, так и «тяжелое», когда для продолжения работы необходима перезагрузка;

•несовпадение полученных результатов с ожидаемыми.

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

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

•неверное определение исходных данных,

•логические ошибки,

•накопление погрешностей результатов вычислений (рис. 10.2).

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

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

Кпоследней группе относят:

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

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

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

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

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

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

опосредованного проявления ошибок;

возможности взаимовлияния ошибок;

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

отсутствия повторяемости проявлений некоторых ошибок от запуска к запуску – так называемые стохастические ошибки;

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

написания отдельных частей программы разными программистами.

Методы отладки программного обеспечения

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

ручного тестирования;

индукции;

дедукции;

обратного прослеживания.

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

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

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

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

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

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

Метод дедукции. По методу дедукции вначале формируют множество причин, которые могли бы вызвать данное проявление ошибки. Затем анализируя причины, исключают те, которые противоречат имеющимся данным. Если все причины исключены, то следует выполнить дополнительное тестирование исследуемого фрагмента. В противном случае наиболее вероятную гипотезу пытаются доказать. Если гипотеза объясняет полученные признаки ошибки, то ошибка найдена, иначе — проверяют следующую причину (рис. 10.4).

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

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

Виды ошибок

Ошибки компиляции

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

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

Ошибки компоновки

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

Ошибки выполнения (RUNTIME Error)

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

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

Ошибки выполнения можно разделить на три большие группы.

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

К ним относятся:

• ошибки преобразования;
• ошибки данных;
• ошибки перезаписи.

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

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

В эту группу входят:

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

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

Методы отладки программного обеспечения

Метод ручного тестирования

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

Метод индукции

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

Вот как выглядит процесс:

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

Метод дедукции

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

Метод обратного прослеживания

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

Как выполняется отладка в современных IDE

Ранние отладчики, например gdb, представляли собой отдельные программы с интерфейсами командной строки. Более поздние, например первые версии Turbo Debugger, были автономными, но имели собственный графический интерфейс для облегчения работы. Сейчас большинство IDE имеют встроенный отладчик. Он использует такой же интерфейс, как и редактор кода, поэтому можно выполнять отладку в той же среде, которая используется для написания кода.

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

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

Шаг с заходом (step into)

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

Шаг с обходом (step over)

Команда также выполняет очередную инструкцию. Однако когда step into будет входить в вызовы функций и выполнять их строка за строкой, step over выполнит всю функцию, не останавливаясь, и вернет управление после ее выполнения. Команда step over позволяет пропустить функции, если разработчик уверен, что они уже исправлены, или не заинтересован в их отладке в данный момент.

Шаг с выходом (step out)

В отличие от step into и step over, step out выполняет не следующую строку кода, а весь оставшийся код функции, исполняемой в настоящее время. После возврата из функции он возвращает управление разработчику. Эта команда полезна, когда специалист случайно вошел в функцию, которую не нужно отлаживать.

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

У некоторых отладчиков (таких как GDB 7.0, Visual Studio Enterprise Edition 15.5 и более поздних версий) есть возможность вернуться на шаг назад. Это полезно, если пропущена цель либо нужно повторно проверить выполненную инструкцию.