Ошибка на этапе компиляции это - Не ошибается лишь тот, кто ничего не делает!

From Wikipedia, the free encyclopedia

Compilation error refers to a state when a compiler fails to compile a piece of computer program source code, either due to errors in the code, or, more unusually, due to errors in the compiler itself. A compilation error message often helps programmers debugging the source code. Although the definitions of compilation and interpretation can be vague, generally compilation errors only refer to static compilation and not dynamic compilation. However, dynamic compilation can still technically have compilation errors,^{[citation needed]} although many programmers and sources may identify them as run-time errors. Most just-in-time compilers, such as the Javascript V8 engine, ambiguously refer to compilation errors as syntax errors since they check for them at run time.^[1]^[2]

Examples[edit]

Common C++ compilation errors[edit]

Undeclared identifier, e.g.:

doy.cpp: In function `int main()': doy.cpp:25: `DayOfYear' undeclared (first use this function)^[3]

This means that the variable «DayOfYear» is trying to be used before being declared.

Common function undeclared, e.g.:

xyz.cpp: In function `int main()': xyz.cpp:6: `cout' undeclared (first use this function)^[3]

This means that the programmer most likely forgot to include iostream.

Parse error, e.g.:

somefile.cpp:24: parse error before `something'^[4]

This could mean that a semi-colon is missing at the end of the previous statement.

Internal Compiler Errors[edit]

An internal compiler error (commonly abbreviated as ICE) is an error that occurs not due to erroneous source code, but rather due to a bug in the compiler itself. They can sometimes be worked around by making small, insignificant changes to the source code around the line indicated by the error (if such a line is indicated at all),^[5]^{[better source needed]} but sometimes larger changes must be made, such as refactoring the code, to avoid certain constructs. Using a different compiler or different version of the compiler may solve the issue and be an acceptable solution in some cases. When an internal compiler error is reached many compilers do not output a standard error, but instead output a shortened version, with additional files attached, which are only provided for internal compiler errors. This is in order to insure that the program doesn’t crash when logging the error, which would make solving the error nigh impossible. The additional files attached for internal compiler errors usually have special formats that they save as, such as .dump for Java. These formats are generally more difficult to analyze than regular files, but can still have very helpful information for solving the bug causing the crash.^[6]

Example of an internal compiler error:

somefile.c:1001: internal compiler error: Segmentation fault
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://bugs.gentoo.org/> for instructions.

References[edit]

^ «Errors | Node.js v7.9.0 Documentation». nodejs.org. Retrieved 2017-04-14.
^ «SyntaxError». Mozilla Developer Network. Retrieved 2017-04-14.
^ ^a ^b «Common C++ Compiler and Linker Errors». Archived from the original on 2008-02-16. Retrieved 2008-02-12.
^ «Compiler, Linker and Run-Time Errors».
^ Cunningham, Ward (2010-03-18). «Compiler Bug». WikiWikiWeb. Retrieved 2017-04-14.
^ జగదేశ్. «Analyzing a JVM Crash». Retrieved 2017-04-15.

Источник

Это ваша первая программа на C (или C++) — она не такая уж большая, и вы собираетесь скомпилировать ее. Вы нажимаете на compile (или вводите команду компиляции) и ждете. Ваш компилятор выдает пятьдесят строк текста. Вы выбираете слова warning и error. Задумываетесь, значит ли это, что все в порядке. Вы ищите полученный исполняемый файл. Ничего. Черт возьми, думаете вы, я должен выяснить, что все это значит …

Типы ошибок компиляции

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

предупреждения компилятора;
ошибки компилятора;
ошибки компоновщика.

Хоть вы и не хотите игнорировать их, предупреждения компилятора не являются чем-то достаточно серьезным, чтобы не скомпилировать вашу программу. Прочитайте следующую статью, которая расскажет вам, почему стоит дружить с компилятором и его предупреждениями. Как правило, предупреждения компилятора — это признак того, что что-то может пойти не так во время выполнения. Как компилятор узнает об этом? Вы, должно быть делали типичные ошибки, о которых компилятор знает. Типичный пример — использование оператора присваивания = вместо оператора равенства == внутри выражения. Ваш компилятор также может предупредить вас об использовании переменных, которые не были инициализированы и других подобных ошибках. Как правило, вы можете установить уровень предупреждений вашего компилятора — я устанавливаю его на самый высокий уровень, так что предупреждения компилятора не превращаются в ошибки в выполняемой программе (“ошибки выполнения”).

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

Ошибки — это условия, которые препятствуют завершению компиляции ваших файлов.

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

line 13, unexpected parenthesis ‘)’

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

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

could not find definition for X

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

Ошибки компилятора — с чего начать?

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

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

struct 
{
   int x;
   int y;
} myStruct;

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

Что-то вроде этого:

struct MyStructType
{
   int x;
   int y;
}

int foo()
{}

может привести к огромному количеству ошибок, возможно, включая сообщения:

extraneous ‘int’ ignored

Все это из-за одного символа! Лучше всего начать с самого верха.

Анализ сообщения об ошибке

Большинство сообщений от компилятора будет состоять как минимум из четырех вещей:

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

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

foo.cc:7: error: semicolon missing after struct declaration

foo.cc это имя файла. 7 — номер строки, и ясно, что это ошибка. Короткое сообщение здесь весьма полезно, поскольку оно показывает именно то, что не правильно. Заметим, однако, что сообщение имеет смысл только в контексте программы. Оно не сообщает, в какой структуре не хватает запятой.

Более непонятным является другое сообщение об ошибке из той же попытки компиляции:

extraneous ‘int’ ignored

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

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

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

Обработка непонятных или странных сообщений

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

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

Второе непонятное сообщение:

unexpected end of file

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

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

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

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

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

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

undefined function

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

Ошибки компоновщика могут произойти в функциях, которые вы объявили и определили, если вы не включили все необходимые объектные файлы в процесс связывания. Например, если вы пишете определение класса в myClass.cpp, а ваша основная функция в myMain.cpp, компилятор создаст два объектных файла, myClass.o и myMain.o, а компоновщику будут нужны оба из них для завершения создания новой программы. Если оставить myClass.o, то у него не будет определения класса, даже если вы правильно включите myClass.h!

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

Последний странный тип ошибки компоновщика — сообщение

undefined reference to main

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

Источник

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

1.2 Разновидности ошибок

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

1.2.1 Ошибки этапа компиляции

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

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

170

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

1.2.2 Ошибки этапа выполнения

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

Когда
программа Turbo
Pascal обнаруживает такую ошибку, она
завершает выполнение и выводит сообщение
следующего вида:

Run-time
error ## at seg:ofs

Если
выполнять программу вне IDE, то можно
запустить IDE и для поиска вызвавшего
ошибку оператора использовать команду
Search|Find Error, которая дает адрес сегмента
и смещения (seg:ofs).

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

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

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

2 Выполнение программы по шагам и трассировка

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

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

171

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

Источник

In one of my prof slides on ploymorphism, I see this piece of code with a couple of comments:

discountVariable =              //will produce
  (DiscountSale)saleVariable;//run-time error
discountVariable = saleVariable //will produce
                                //compiler error

As you can see, it says in the first casting statement that it’ll produce run-time error and in the other one it says it’ll produce compiler error.

What makes these errors? and how they differ from each other?

The Unfun Cat

28.7k29 gold badges109 silver badges150 bronze badges

asked Feb 27, 2012 at 20:31

A run time error will only occur when the code is actually running.
These are the most difficult — and lead to program crashes and bugs in your code which can be hard to track down.

An example might be trying to convert a string: «hello» into an integer:

string helloWorld = "hello";
int willThrowRuntimeError = Convert.ToInt32(helloWorld);

The compiler may not see this as a problem but when run an error will be thrown.

Compiler errors are due to inaccuracies in code, where the compiler throws an error to alert you to something which will not compile, and therefore cannot be run.

An example of a compiler error would be:

int = "this is not an int";

user

3,9355 gold badges17 silver badges34 bronze badges

answered Feb 27, 2012 at 20:38

DIXONJWDDDIXONJWDD

1,24610 silver badges20 bronze badges

A runtime error happens during the running of the program. A compiler error happens when you try to compile the code.

If you are unable to compile your code, that is a compiler error.

If you compile and run your code, but then it fails during execution, that is runtime.

answered Feb 27, 2012 at 20:33

James MontagneJames Montagne

76.8k14 gold badges108 silver badges129 bronze badges

Compile time errors refers to syntax and semantics. For example, if you do operations that involves different types. Ex: adding a string with an int, or dividing a string by a real. (read the last paragraph thou!!!)

Run Time errors are those that are detected when the program execute. For example, division by zero. The compiler can not know if the operation x/a-b will leads to division by zero until the execution.

This is a very broad explanation. There are many smart compilers, and, also, is possible to do internal casting among different types that leads to operations that make sense. It it possible to pre-compile code and see some run time errors even if the code is not executed.

Refer to this link too: Runtime vs Compile time

answered Feb 27, 2012 at 20:37

Compile time errors are errors of syntax and semantics.

Run time errors are errors of logic primarily. Due to something the programmer has overlooked, the program crashes e.g. division by 0, accessing a variable without initializing it first etc.

answered Jun 8, 2015 at 7:03

HadiHadi

5008 silver badges20 bronze badges

Compile Time error means that the Compiler knows that discountVariable = saleVariable must be end with a semi colon as belowdiscountVariable = saleVariable;so it will throw an error when you compile the code.

Run Time error means that the error will occur at run time, because even though you are casting saleVariable into discountVariable, the cast cannot take because they differ in type.

answered Feb 27, 2012 at 20:33

CodeBlueCodeBlue

14.5k32 gold badges92 silver badges131 bronze badges

think you’ve already got the general desc of what’s the difference. Specifically in the code you have shown in the OP,

In second statement, compiler compares the types on LHS and RHS and finds no implicit cast possible so it gives the error.
first statement is seen by compiler as the same, but here programmer explicitly casts the type, which is as good as telling compiler that I know what I’m doing and of course the compiler trusts you and gives you no errors.

answered Feb 27, 2012 at 20:50

KashyapKashyap

14.5k12 gold badges63 silver badges100 bronze badges

Its because the compiler doesn’t know the object type of «saleVariable» until that value has actually been set when the program is running.

Your are forcing whatever is in salesVariable into the type DiscountSale this is considered unsafe and cannot be evaluated until runtime.

answered Feb 27, 2012 at 20:33

bigamilbigamil

6574 silver badges12 bronze badges

Compilation/Compile time/Syntax/Semantic errors: Compilation or compile time errors are error occurred due to typing mistake, if we do not follow the proper syntax and semantics of any programming language then compile time errors are thrown by the compiler. They wont let your program to execute a single line until you remove all the syntax errors or until you debug the compile time errors.
Example: Missing a semicolon in C or mistyping int as Int.

Runtime errors: Runtime errors are the errors that are generated when the program is in running state. These types of errors will cause your program to behave unexpectedly or may even kill your program. They are often referred as Exceptions.
Example: Suppose you are reading a file that doesn’t exist, will result in a runtime error.

Read more about all programming errors here

answered May 25, 2015 at 5:37

If you’d use Google, you’d get this:

Compile time error is any type of error that prevent a java program compile like a syntax error, a class not found, a bad file name for the defined class, a possible loss of precision when you are mixing different java data types and so on.

A runtime error means an error which happens, while the program is running. To deal with this kind of errors java define Exceptions. Exceptions are objects represents an abnormal condition in the flow of the program. It can be either checked or unchecked.

http://wiki.answers.com/Q/Difference_between_run_time_error_and_compile_time_error_in_java

answered Feb 27, 2012 at 20:32

Compiler errors are due to inaccuracies in code, where the compiler throws an error to alert you to something which will not compile, and therefore cannot be run.

Ex :- MethodOverloading

class OverloadingTest {
    void sum(int a, long b) {
        System.out.println("a method invoked");
    }

    void sum(long a, int b) {
        System.out.println("b method invoked");
    }

    public static void main(String args[]) {
        OverloadingTest obj = new OverloadingTest();
        obj.sum(200, 200);// now ambiguity
    }
}

Run Time errors are those that are detected when the program execute. For example, division by zero. The compiler can not know if the operation x/a-b will leads to division by zero until the execution

answered Apr 21, 2015 at 8:48

Nikhil KumarNikhil Kumar

2,4983 gold badges19 silver badges24 bronze badges

In one of my prof slides on ploymorphism, I see this piece of code with a couple of comments:

discountVariable =              //will produce
  (DiscountSale)saleVariable;//run-time error
discountVariable = saleVariable //will produce
                                //compiler error

As you can see, it says in the first casting statement that it’ll produce run-time error and in the other one it says it’ll produce compiler error.

What makes these errors? and how they differ from each other?

The Unfun Cat

28.7k29 gold badges109 silver badges150 bronze badges

asked Feb 27, 2012 at 20:31

A run time error will only occur when the code is actually running.
These are the most difficult — and lead to program crashes and bugs in your code which can be hard to track down.

An example might be trying to convert a string: «hello» into an integer:

string helloWorld = "hello";
int willThrowRuntimeError = Convert.ToInt32(helloWorld);

The compiler may not see this as a problem but when run an error will be thrown.

Compiler errors are due to inaccuracies in code, where the compiler throws an error to alert you to something which will not compile, and therefore cannot be run.

An example of a compiler error would be:

int = "this is not an int";

user

3,9355 gold badges17 silver badges34 bronze badges

answered Feb 27, 2012 at 20:38

DIXONJWDDDIXONJWDD

1,24610 silver badges20 bronze badges

A runtime error happens during the running of the program. A compiler error happens when you try to compile the code.

If you are unable to compile your code, that is a compiler error.

If you compile and run your code, but then it fails during execution, that is runtime.

answered Feb 27, 2012 at 20:33

James MontagneJames Montagne

76.8k14 gold badges108 silver badges129 bronze badges

Refer to this link too: Runtime vs Compile time

answered Feb 27, 2012 at 20:37

Compile time errors are errors of syntax and semantics.

Run time errors are errors of logic primarily. Due to something the programmer has overlooked, the program crashes e.g. division by 0, accessing a variable without initializing it first etc.

answered Jun 8, 2015 at 7:03

HadiHadi

5008 silver badges20 bronze badges

Run Time error means that the error will occur at run time, because even though you are casting saleVariable into discountVariable, the cast cannot take because they differ in type.

answered Feb 27, 2012 at 20:33

CodeBlueCodeBlue

14.5k32 gold badges92 silver badges131 bronze badges

think you’ve already got the general desc of what’s the difference. Specifically in the code you have shown in the OP,

In second statement, compiler compares the types on LHS and RHS and finds no implicit cast possible so it gives the error.
first statement is seen by compiler as the same, but here programmer explicitly casts the type, which is as good as telling compiler that I know what I’m doing and of course the compiler trusts you and gives you no errors.

answered Feb 27, 2012 at 20:50

KashyapKashyap

14.5k12 gold badges63 silver badges100 bronze badges

Its because the compiler doesn’t know the object type of «saleVariable» until that value has actually been set when the program is running.

Your are forcing whatever is in salesVariable into the type DiscountSale this is considered unsafe and cannot be evaluated until runtime.

answered Feb 27, 2012 at 20:33

bigamilbigamil

6574 silver badges12 bronze badges

Read more about all programming errors here

answered May 25, 2015 at 5:37

If you’d use Google, you’d get this:

Compile time error is any type of error that prevent a java program compile like a syntax error, a class not found, a bad file name for the defined class, a possible loss of precision when you are mixing different java data types and so on.

A runtime error means an error which happens, while the program is running. To deal with this kind of errors java define Exceptions. Exceptions are objects represents an abnormal condition in the flow of the program. It can be either checked or unchecked.

http://wiki.answers.com/Q/Difference_between_run_time_error_and_compile_time_error_in_java

answered Feb 27, 2012 at 20:32

Compiler errors are due to inaccuracies in code, where the compiler throws an error to alert you to something which will not compile, and therefore cannot be run.

Ex :- MethodOverloading

class OverloadingTest {
    void sum(int a, long b) {
        System.out.println("a method invoked");
    }

    void sum(long a, int b) {
        System.out.println("b method invoked");
    }

    public static void main(String args[]) {
        OverloadingTest obj = new OverloadingTest();
        obj.sum(200, 200);// now ambiguity
    }
}

answered Apr 21, 2015 at 8:48

Nikhil KumarNikhil Kumar

2,4983 gold badges19 silver badges24 bronze badges

Определение
понятия ошибки и исключения.
Классификация
ошибок.
Общий способ обработки
ошибок.
Обработка ошибок в языке Java.

— исключение в Java.

— причины возникновения исключений
в Java

— конструкция обработки исключения

— асинхронные исключения
—
иерархия исключений
—
классы Exception и RuntimeException

— класс Error
Приложения.

Определение понятия ошибки и исключения.

В
качестве введения рассмотрим определения
понятия «ошибка». Начнем с наиболее
общего трактования этого:
В самом
общем случае под ошибкой понимается
какой-то сбой в программе на этапе ее
выполнения.
По определению стандарта
ISO
9241-13 ошибка это – несоответствие между
целями пользователя и ответом системы.

Ошибкой также можно назвать
недокументированные или нежелательные,
«побочные» реакции программы на
те или иные действия пользователя равно
как и при использовании ее одновременно
с другим программами или на другой
аппаратной платформе.
В книге «К.
Браун, Р. Калбертсон, Г. Кобб. Быстрое
тестирование» приводится такое
определение программных ошибок: «Говоря
простыми словами, программная ошибка
— не что иное, как изъян в разработке
программного продукта, который вызывает
несоответствие ожидаемых результатов
выполнения программного продукта и
фактически полученных результатов.
Дефект может возникнуть на стадии
кодирования, на стадии формулирования
требований или на стадии проектирования,
либо же его причина может крыться в
некорректной конфигурации или данных.
Дефектом может быть также что-то другое,
что не соответствует ожиданиям заказчика
и что может быть, а может и не быть
определено в спецификации программного
продукта».
Для исключения Г.
Шилдт дает такое определение: исключение
– это нештатная ситуация , возникающая
во время выполнения последовательности
кода.
Как можно заметить, под понятием
ошибки и исключительной ситуацией можно
подразумевать одно и то же.
Исключение
— это некое специальное событие, которое
сигнализирует об ошибке в программе.
Другими
словами, исключение – это ошибка времени
выполнения.

Классификация
ошибок.

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

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

1. Описания идентификаторов.

1. Неинициализированный
указатель.
2.
Неинициализированная переменная.

3. Ошибочная инициализация.

2. Статический контроль
типов.
1. Не корректное
присваивание.
2. Не
корректная операция.

3. Не корректная передача параметров.

Ошибки
выполнения:
1. Синхронные ошибки.

1. Ошибки определения данных.

1. Ошибки передачи.
2.
Ошибки преобразования.
3.
Ошибки перезаписи.
4. Ошибочные
данные.
5. Динамический
контроль типов.
6. Ошибки
индексации.
2. Ошибки накопления
погрешностей.
1. Игнорирование
способов уменьшения погрешностей.

2. Переполнение разрядной
сетки.
3. Арифметические ошибки.

4. Ссылочные ошибки.
5. Ошибки
сети.
6. Ошибки ввода/вывода.
2.
Асинхронные ошибки.
1. Ошибки
виртуальной машины.
2. Ошибки системы.

Ошибки
компоновки
1. Ошибки получения
данных по внешним ссылкам.
2.
Объединение модулей
1. Ошибки
обнаружения модулей.
2.
Ошибка состыковки списков параметров
модулей.

Логические
ошибки
1. Ошибки проектирования

1. Неприменимый метод.

2. Неверный алгоритм.

3. Неверная структура данных.
2.
Ошибки кодирования
1.
Некорректное вычисление.

2. Ошибки реализации алгоритмов.

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

Разница между ошибками времени компиляции и ошибками времени выполнения

29.12.2019Разница между, Язык программирования

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

Отсутствует скобка ( } )
Печать значения переменной без ее объявления
Отсутствует точка с запятой (терминатор)

Ниже приведен пример для демонстрации ошибки времени компиляции:

#include<stdio.h>

void main()

{

int x = 10;

int y = 15;

printf("%d", (x, y))

}

Ошибка:

error: expected ';' before '}' token

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

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

#include<stdio.h>

void main()

{

int n = 9, div = 0;

div = n/0;

printf("resut = %d", div);

}

Ошибка:

warning: division by zero [-Wdiv-by-zero]
     div = n/0;

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

Различия между временем компиляции и ошибкой во время выполнения:

Compile-Time Errors	Runtime-Errors
These are the syntax errors which are detected by the compiler.	These are the errors which are not detected by the compiler and produce wrong results.
They prevent the code from running as it detects some syntax errors.	They prevent the code from complete execution.
It includes syntax errors such as missing of semicolon(;), misspelling of keywords and identifiers etc.	It includes errors such as dividing a number by zero, finding square root of a negative number etc.

Рекомендуемые посты:

Разница между ОС с разделением времени и ОС реального времени
Как избежать ошибки компиляции при определении переменных
Разница между процессором и графическим процессором
Разница между CLI и GUI
Разница между PNG и GIF
В чем разница между MMU и MPU?
Разница между BFS и DFS
Разница между RPC и RMI
Разница между C и C #
Разница между JSP и ASP
Разница между светодиодом и ЖК
Разница между MP4 и MP3
Разница между LAN, MAN и WAN
Разница между 4G и 5G
Разница между LAN и WAN

Разница между ошибками времени компиляции и ошибками времени выполнения

0.00 (0%) 0 votes

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

Отсутствует скобка ( } )
Печать значения переменной без его объявления
Отсутствует точка с запятой (терминатор)

Ниже приведен пример, демонстрирующий ошибку времени компиляции:

#include<stdio.h>

void main()

{

int x = 10;

int y = 15;

printf ( "%d" , (x, y))

}

Ошибка:

 ошибка: ожидается ';' перед токеном '}'

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

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

Ошибка:

 предупреждение: деление на ноль [-Wdiv-by-zero]
     div = n / 0;

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

Различия между ошибкой времени компиляции и ошибкой времени выполнения:

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

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

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

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

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

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

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

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

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

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

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

Рассмотрим данный пример:

3 + 5 * 6

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

(3 + 5) * 6

3 + 5, заключенные в скобки, дадут желаемый результат, а именно 48.

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

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

Вот хороший пример:

input = 25
x = 0.8/(Math.sqrt(input) - 5)

Фрагмент кода выше будет скомпилирован успешно, но input 25 приведет к ZeroDivisionError. Это ошибка во время выполнения. Другим популярным примером является StackOverflowError или IndexOutofBoundError. Важно то, что вы идентифицируете эти ошибки и узнаете, как с ними бороться.

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

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

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

Вот несколько советов о том, как правильно выполнять отладку:

Использовать Linters. Linters – это инструменты, которые помогают считывать исходный код, чтобы проверить, соответствует ли он ожидаемому стандарту на выбранном языке программирования. Существуют линты для многих языков.
Превалирование IDE над простыми редакторами. Вы можете выбрать IDE, разработанную для языка, который изучаете. IDE – это интегрированные среды разработки. Они созданы для написания, отладки, компиляции и запуска кода. Jetbrains создают отличные IDE, такие как Webstorm и IntelliJ. Также есть NetBeans, Komodo, Qt, Android Studio, XCode (поставляется с Mac), etc.
Чтение кода вслух. Это полезно, когда вы ищете семантическую ошибку. Читая свой код вслух, есть большая вероятность, что вы зачитаете и ошибку.
Чтение логов. Когда компилятор отмечает Error, обязательно посмотрите, где он находится.

Двигаемся дальше

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

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

Викторина

Какая ошибка допущена в фрагменте кода Python ниже?

items = [0,1,2,3,4,5]
print items[8]
//комментарий: элементы здесь представляют собой массив с шестью элементами. Например, чтобы получить 4-й элемент, вы будете использовать [3]. Мы начинаем отсчет с 0.

Какая ошибка допущена в фрагменте кода Python ниже?

input = Hippo'
if input == 'Hippo':
  print 'Hello, Hippo'

Ответы на вопросы

Ошибка выполнения: ошибка индекса вне диапазона.

2. Синтаксическая ошибка: Отсутствует стартовая кавычка в первой строке.

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

В примере может потребоваться преобразовать строку: «hello» в целое число:

string helloWorld = "hello";
int willThrowRuntimeError = Convert.ToInt32(helloWorld);

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

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

Пример ошибки компилятора:

int = "this is not an int";

Надеюсь, что это поможет.

jwddixon
27 фев. 2012, в 22:09

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

Если вы не можете скомпилировать свой код, это ошибка компилятора.

Если вы компилируете и запускаете свой код, но затем он не выполняется во время выполнения, это время выполнения.

James Montagne
27 фев. 2012, в 21:04

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

Ошибки времени выполнения — это те, которые обнаруживаются при выполнении программы. Например, деление на ноль. Компилятор не может знать, приведет ли операция x/a-b к делению на ноль до выполнения.

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

См. также эту ссылку: Время выполнения и время компиляции

Kani
27 фев. 2012, в 20:43

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

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

Hadi
08 июнь 2015, в 07:21

Ошибка компиляции означает, что компилятор знает, что discountVariable = saleVariable должен быть завершен с помощью двоеточия ниже discountVariable = saleVariable;, поэтому он будет вызывать ошибку при компиляции кода.

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

CodeBlue
27 фев. 2012, в 20:52

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

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

Kashyap
27 фев. 2012, в 21:47

Потому что компилятор не знает тип объекта «saleVariable», пока это значение не было установлено, когда программа запущена.

Вы заставляете все, что есть в salesVariable, в тип DiscountSale, это считается небезопасным и не может быть оценено до времени выполнения.

bigamil
27 фев. 2012, в 20:56

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

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

Подробнее о ошибки программирования здесь

Pankaj Prakash
25 май 2015, в 05:39

Пример: — Метод загрузки

class OverloadingTest {
    void sum(int a, long b) {
        System.out.println("a method invoked");
    }

    void sum(long a, int b) {
        System.out.println("b method invoked");
    }

    public static void main(String args[]) {
        OverloadingTest obj = new OverloadingTest();
        obj.sum(200, 200);// now ambiguity
    }
}

Ошибки времени выполнения — это те, которые обнаруживаются при выполнении программы. Например, деление на ноль. Компилятор не может знать, приведет ли операция x/a-b к делению на ноль до выполнения

Nikhil Kumar
21 апр. 2015, в 09:39

Если вы используете Google, вы получите следующее:

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

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

http://wiki.answers.com/Q/Difference_between_run_time_error_and_compile_time_error_in_java

user647772
27 фев. 2012, в 20:42

Ещё вопросы

0Как html переносить текст, но разбивать слова, если они слишком длинные
0Доктрина корней деревьев
1Как скомпилировать делегата с помощью Mono.CSharp.Evaluator?
0Создание аналитики PHP для каждого профиля пользователя
1Как правильно ждать завершения недоступной операции
1извлечение имени файла с расширением формы URL
0перед вставкой проверьте уже существующие данные в базе данных
0AngularJS украшает $ q с сокращением для .notify
0Возникли проблемы с директивой в AngularJS
0Передача значений из родительской директивы в дочернюю директиву после возврата $ http
1Как получить все выходные в диапазоне дат в C #
0Инициализация структуры itimerspec — это хороший выбор memset?
0Как отобразить всплывающую подсказку «Значок даты» (нажмите, чтобы открыть календарь даты)
0Мостовое соединение MySQL-Oracle
0Получить данные whois для короткого доменного имени
1UrlConnection без типа контента
0Как предотвратить $ event for fire дважды
1макет ресурса в сервисе java (mockito)
1Измените тип объекта на его подтип и верните его
1Функция не передает параметры в onclick
0Возврат ответа на onClientClick на основе выбора пользовательской кнопки
1Mirth Javascript импорт
0PHP — формат HTML-теги b в теги заголовка
1Spring Content Negotiation / OpenCSV: получение пустого CSV
0Не будет отображать изображение на мобильном телефоне
0Получить среднее значение значений строк каждого месяца и сгруппированных по пользователю
0Mysql / php сортировка по второму слову varchar
1Как я могу удалить n t из строки в списке <string>?
1Можно ли скрыть номер, который вызывается из приложения?
0Получить значение элемента управления добавлением из кода в ASP.NET
0Калькулятор прожитых дней не всегда дает точные результаты
1Android добавить контактный адрес электронной почты
1Когда использовать конструктор и супер в Polymer 2.0?
1Линейный график становится пустым (показывает большой красный х)
0Массив списка <string>, вставка строки ведет себя странно
0угловой тест не выполняет код директивы
1логиты и метки должны быть транслируемыми с ошибками в Tensorflow RNN
0Как применить темы к HTML внутри метода append ()
1Проблема с многопоточностью при подключении к нескольким устройствам одновременно
1Начало работы с разработкой Android на Eclipse Pulsar
0Функция автозапуска для базового слайдера jquery?
1Как оптимизировать ListView с разным макетом элемента
1Как найти не дочерний вид в Android?
1Как приложение Контакты на Android?
0Параметр контрольной суммы в MYSQL для назначения каждому полю
1Может ли фоновое Android-приложение делать скриншоты активного в данный момент экрана?
0показывает Jquery UI DatePicker по нажатию asp: linkbutton
0Подсчет записей в MySQL с помощью сложного оператора HAVING
0используя функцию localtime для получения локального времени пользователя в php
0Работа с couchdb и push to git repo в проекте angularjs

Источник

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

PHP и MySQL
Основы PHP
Отладка программ

Внимание! Данный курс устарел!
Переходите к новому курсу «PHP для начинающих».

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

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

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

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

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

Общие стратегии поиска неисправностей

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

Внесение изменений только в одном месте

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

Ограничение области проявления проблемы

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

Кроме того, для контроля над функционированием программ и за поведением компонентов программ в ходе их функционирования можно использовать отладчик с графическим интерфейсом (такой как Zend Studio).

Упрощение и последующее усложнение

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

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

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

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

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

Общая классификация ошибок

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

Ошибки на этапе компиляции

Язык PHP является компилируемым, но компиляция программы осуществляется непосредственно перед ее выполнением, поэтому сам процесс компиляции не столь очевиден, как в языке C или Java.

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

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

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

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

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

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

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

Использование журналов веб-сервера

Эксплуатация большинства программ PHP приводит к получению HTML-страниц того или иного рода, а эти страницы, в свою очередь, передаются пользователю с помощью HTTP-сервера, такого как Apache или Microsoft Internet Information Server (IIS). Это означает, что дополнительным источником ошибок может стать программное обеспечение веб-сервера. По этой причине важно знать, какой способ применяется в веб-сервере для формирования и регистрации сообщений об ошибках, а также знать о том, как получить доступ и провести синтаксический анализ журналов, в которых регистрируются ошибки.

Сервер Apache

На HTTP-сервере Apache ведутся два файла журнала в формате открытого текста. Эти журналы описаны ниже:

Apache/logs/access.log: Предназначен для регистрации каждого запроса на получение файла, передаваемого по протоколу HTTP. К регистрируемым данным относятся дата, время и полученные результаты (успешное или неудачное завершение, о чем можно судить по числовому коду состояния). Этот журнал представляет собой также журнал регистрации доступа, в котором фиксируется IP-адрес, из которого поступил каждый запрос.
Apache/logs/error.log: Это — журнал регистрации ошибок, в котором фиксируются только ситуации, связанные с возникновением ошибок.

Унифицированный формат журнала

По умолчанию для оформления записей в файле error.log сервера Apache используется унифицированный формат журнала, который принят в качестве стандартного. В этом формате каждая запись соответствует отдельному экземпляру действия, касающегося запроса и/или ответа (в конечном итоге HTTP-серверы занимаются обработкой именно запросов и ответов). Например, одна строка журнала может соответствовать запросу на получение HTML-страницы (и содержать сведения о том, в каких обстоятельствах эта страница была впоследствии предоставлена сервером Apache). А следующая строка может описывать (автоматическое) выполнение запроса и передачу файла JPEG, связанного с ранее затребованным документом HTML.

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

127.0.0.1 - - [12/Jan/2013:03:18:33 +0800] "GET /images/lang.gif HTTP/1.1" 200 6590

Ниже перечислены наиболее важные компоненты данной строки:

127.0.0.1. IP-адрес клиента, от которого поступил запрос по протоколу HTTP (в данном случае локальный хост).
[12/Jan/2013:03:18:33 +0400]. Дата, время и разница между временем текущего часового пояса и всеобщим скоординированным временем (Universal Coordinated Time — UTC).
GET. Тип запроса HTTP — GET или POST.
/images/lang.gif. Затребованный файл.
HTTP/1.1. Версия протокола HTTP, используемого для передачи запроса.
200. Код ответа, описывающий результат запроса (дополнительная информация на эту тему приведена ниже в данном разделе).
6590. Количество байтов, переданных в ответе HTTP, соответствующем этому запросу.

Коды ответов HTTP

Количество кодов ответов HTTP весьма велико (хотя самым знаменитым остается код сообщения об ошибке «404 Not Found»), но сами эти коды подчиняются общему шаблону, с помощью которого можно быстро узнать назначение каждого кода. По существу, данные шаблоны подразделяются на категории, описанные ниже:

Коды ряда 200 указывают на успешное завершение.
Коды ряда 300 обозначают перенаправление.
Коды ряда 400 указывают на клиентскую ошибку (подобную указанию в запросе несуществующего документа).
Коды ряда 500 указывают на серверную ошибку.

Полный список кодов ответов HTTP приведен по адресу www.w3.org/Protocols/rfc2616/rfc2616-sec10.html.

Сервер IIS

В HTTP-сервере IIS компании Microsoft задача ведения журнала осуществляется иначе. Сервер IIS не записывает журнал в файл, а регистрирует полученную им информацию о состоянии и об обнаруженных ошибках таким образом, чтобы эта информация была доступна для исследования в программе Event Viewer. Ошибки, зарегистрированные сервером IIS, можно найти в части System Log окна Event Viewer, где для обозначения источника применяется имя W3SVC.

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

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

Формирование сообщений об ошибках

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

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

display_errors=On

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

display_errors=Off

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

Регистрация ошибок

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

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

log_errors=On

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

log_errors=Off

По умолчанию средства регистрации ошибок запрещены в файле php.ini.

Определение категории ошибок, подлежащих выводу на экран или записи в журнал

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

error_reporting=E_ALL & ~E_NOTICE

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

Степень серьезности отображаемых сообщений об ошибках, которая определена параметром error_reporting, отражается на поведении средств регистрации ошибок (если их использование разрешено с помощью параметра log_errors=On) и средств формирования сообщений об ошибках (если их использование разрешено с помощью параметра display_errors=On) или одновременно тех и других средств, если все они разрешены.

Функции формирования сообщений об ошибках

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

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

Диагностические операторы вывода

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

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

Использование функции var_dump()

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

Напомним, что выполнение приведенного ниже кода приводит к получению результатов, от которых мало пользы:

Код PHP

$fruit = array('orange' => 'Апельсин',
			   'red' => 'Яблоко',
			   'yellow' => 'Банан',
			   'green' => 'Груша');
echo $fruit;

Данные результаты сводятся к следующему:

Использование конструкции echo для вывода массива

Это нам ничего не дает. С другой стороны, если за определением того же массива следует строка

Код PHP

var_dump($fruit);

то формируется следующие намного более полезные выходные данные:

Использование функции var_dump() для вывода массива

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

Использование функции syslog()

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

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

Все возможные опции определения степени серьезности функции syslog() показаны в следующем коде:

Код PHP

$logOptions = array(LOG_DEBUG, LOG_INFO, LOG_NOTICE, LOG_WARNING,
                LOG_ERR, LOG_CRIT, LOG_ALERT, LOG_EMERG);
				
$msg = array('Сообщение отладки', 'Информация', 'Уведомление', 'Предупреждение', 
                'Ошибка', 'Критическая ошибка', 'Серьезная ошибка', 'Кабздец');

foreach($logOptions as $key => $value) {
	syslog($value, $msg[$key]);
}

В системе Microsoft Windows первые три из этих сообщений об ошибках (от LOG_DEBUG до LOG_NOTICE) рассматриваются как информационные, четвертое и пятое считаются предупреждающими, а последние три отмечаются в программе Event Viewer как относящиеся к категории Alerts. Все эти сообщения отображаются со значением источника c-client, которое соответствует одному из вспомогательных процессов сервера Apache:

Сообщения об ошибках с различными степенями серьезности в программе Event Viewer

Использование функции error_log()

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

Нарушения в работе системы PHP

Безопасность

Оценить статью:

Источник

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

Перевод статьи Error Handling in Compiler Designopen in new window.

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

Типы источников ошибок

Источники ошибок делятся на два типа: ошибки времени выполнения (run-time error) и ошибки времени компиляции (compile-time error).

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

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

Типы ошибок времени компиляции

Ошибки компиляции разделяются на:

Лексические (Lexical): включают в себя опечатки идентификаторов, ключевых слов и операторов
Синтаксические (Syntactical): пропущенная точка с запятой или незакрытая скобка
Семантические (Semantical): несовместимое значение при присвоении или несовпадение типов между оператором и операндом
Логические (Logical): недостижимый код, бесконечный цикл

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

Восстановление после ошибок

Базовое требование к компилятору — прервать компиляцию и выдать сообщение при появлении ошибки. Кроме этого есть несколько методов восстановления после ошибки.

Panic mode recovery

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

Пример: рассмотрим выражение с ошибкой (1 + + 2) + 3. При обнаружении второго + пропускаются все символы до следующего числа.

Phase level recovery

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

Error productions

Разработчики компиляторов знают часто встречаемые ошибки. При появлении таких ошибок могут применяться расширения грамматики для их обработки. Например: написание 5x вместо 5*x.

Global correction

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

Источник

Отладка, или 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 и более поздних версий) есть возможность вернуться на шаг назад. Это полезно, если пропущена цель либо нужно повторно проверить выполненную инструкцию.

Источник

Море(!) аналитической информации!

Глава 6. Отладка в интегрированной среде

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

             IDE для DOS Borland Pascal предоставляет вам  инструменталь-
        ные средства  для отладки программ,  то есть поиска и исправления
        ошибок. В этой главе описываются инструментальные средства и про-
        цедуры отладки программы в интегрированной среде, включая следую-
        щие темы:

             * обзор ошибок и методов отладки;

             * управление выполнением программы;

             * проверка значений;

             * остановки выполнения программы.

             Данная глава посвящена встроенному отладчику  IDE  для  DOS.
        Все описанные  процедуры применимы также к Турбо отладчику (Turbo
        Debugger) и Турбо отладчику для Windows,  хотя имена меню и нажи-
        маемые клавиши в них могут отличаться.



Что такое отладка?

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


Какие существуют виды ошибок?

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

                             Ошибки этапа компиляции

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

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

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

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

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

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

             Когда программа  Borland  Pascal  обнаруживает такую ошибку,
        она завершает выполнение и выводит сообщение следующего вида:

             Run-time error ## at seg:ofs

             Если вы выполняете программу из IDE,  Borland Pascal автома-
        тически находит вызвавший ошибку оператор (как в случае синтакси-
        ческих ошибок). Если вы выполняете программу вне IDE, то вы може-
        те запустить  IDE и,  чтобы найти вызвавший ошибку оператор,  ис-
        пользовать команду Search|Find Error, которая дает вам адрес сег-
        мента и  смещения  (seg:ofs).  Если вы используете компилятор ко-
        мандной строки, то можете для поиска ошибки использовать параметр
        /F.

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

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

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



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

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

             В данном разделе описываются различные возможности отладки в
        IDE для DOS Borland Pascal.

                        Выполнение по шагам и трассировка

             Команды выполнения по шагам Step Over  и  трассировки  Trace
        Into меню  выполнения Run дают вам возможность построчного выпол-
        нения программы. Единственное отличие выполнения по шагам и трас-
        сировки состоит  в  том,  как  они работают с вызовами процедур и
        функций. Выполнение по шагам вызова процедуры или функции интерп-
        ретирует вызов  как  простой оператор и после завершения подпрог-
        раммы возвращает  управление  на  следующую  строку.  Трассировка
        подпрограммы загружает  код  этой  подпрограммы  и  продолжает ее
        построчное выполнение.

                              Остановка выполнения

             Существует два способа сообщить IDE, что программу нужно вы-
        полнить до определенной точки, а затем остановить. Первый и прос-
        тейший способ состоит в том, чтобы найти позицию в программе, где
        вы хотите  остановиться,  затем  выбрать в меню Run команду Go to
        Cursor (Выполнение до позиции курсора). Ваша программа выполняет-
        ся как обычно,  пока не достигнет оператора, где она должна оста-
        новиться. В этой точке вы можете проверить значения и  продолжать
        выполнение непрерывно или по шагам.

             Второй способ состоит в том, чтобы остановить в определенной
        заданной точке вашу программу.  Эта точка называется точкой оста-
        нова. Когда  вы  выполняете программу,  она останавливается перед
        выполнением оператора в точке останова.  Точки останова - это бо-
        лее гибкий механизм, чем использование метода выполнения до пози-
        ции курсора (Go to Cursor), поскольку в программе вы можете уста-
        новить несколько точек останова.

                           Отслеживание и модификация

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


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

                                      Поиск

             Если вам нужно найти  в  программе  описания  процедуры  или
        функции, либо определения объекта,  это легко можно сделать с по-
        мощью средства просмотра объектов ObjectBrowser.  С помощью  меню
        Search и выбора команд Objects,  Globals, Units или Symbols выбе-
        рите соответствующее окно просмотра. См. Главу 4 ("Программирова-
        ние в интегрированной среде для DOS"), где о просмотре кода расс-
        казывается более подробно.



Генерация отладочной информации

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

             Когда вы компилируете программу Borland  Pascal,  компилятор
        всегда сохраняет список используемых идентификаторов, который на-
        зывается таблицей идентификаторов.  В этом  списке  отслеживаются
        имена всех переменных,  констант,  типов, процедур и функций. Для
        целей отладки там сохраняются также номера строк исходных файлов,
        где встречаются все эти идентификаторы.  Выбрав в диалоговом окне
        Compiler Options параметр Debug Information (Отладочная  информа-
        ция) или задав директиву компилятора $D+,  вы указываете компиля-
        тору, что в таблицу идентификаторов нужно добавить  информацию  о
        номерах строк.

                         Встроенная и автономная отладка

             В диалоговом  окне  параметров  отладчика  Debugger  Options
        (Options|Debugger) вы можете сообщить компилятору, нужно ли гене-
        рировать отладочную  информацию для использования встроенного или
        автономного отладчика (такого как Turbo Debugger), или для обоих.
        Если вы хотите использовать встроенный отладчик, то нужно выбрать
        параметр Integrated (который устанавливается по умолчанию).

                              Информация в модулях

             Если вы пишете большую программу, которая использует модули,
        и отладочная  информация  получается слишком объемной,  вы можете
        сократить объем этой информации для отдельных модулей,  используя
        в них  директиву  компилятора  $L-  или отменив в диалоговом окне
        Compiler Options параметр Local Symbols (Информация  о  локальных
        идентификаторах).

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




Управление выполнением

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

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

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




Что такое шаг?

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

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



Выполнение программы по шагам

             Выполнение по шагам - это простейший способ выполнения прог-
        раммы по элементарным фрагментам. Выбор команды Run|Step Over или
        нажатие клавиши  F8  вызывает  выполнение отладчиком всего кода в
        операторе, указанном строкой выполнения, включая любые вызываемые
        на ней процедуры или функции, пока управление не вернется обратно
        к вам. После этого строка выполнения указывает следующий выполня-
        емый оператор.

             Возьмем, например, следующий пример программы:

             program StepTest;

                function Negate(X: Integer): Integer;
                begin
                   Negate := -X;
                end;

             var
                I: Integer;
             begin
                for I := 1 to 10 do Writeln(Negate(I));
             end.

             Пример 6.1 Простая программа, выполняемая по шагам.

             Если в окне редактирования вы выведите  StepTest  и  нажмете
        клавишу F8, то строка выполнения перемещается на оператор begin в
        начале основного цикла,  поскольку это первое,  что выполняется в
        программе. Второе нажатие клавиши F8 выполняет begin и перемещает
        строку выполнения вниз до оператора for на следующей строке. Пос-
        ле этого нажатие F8 вызывает выполнение всего цикла for; на экран
        пользователя выводятся числа от -1 до -10,  а  строка  выполнения
        перемещается к end.

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

             begin
                for I := 1 to 10 do
                  Writeln(Negate(I));
             end.

             Пример 6.2 Изменение формата кода для лучшего выполнения  по
        шагам.

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




Трассировка программы

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

             Например, чтобы  выполнить  трассировку  кода в Примере 6.1,
        загрузите файл, затем выберите команду Run|Trace Into или нажмите
        клавишу F7. Когда вы в первый раз делаете это, управление переме-
        щается на оператор begin основной программы. Повторное нажатие F7
        снова перемещает  строку управления на оператор for.  После этого
        нажатие клавиши F7 трассирует вызов функции Negate -  строка  вы-
        полнения перемещается на оператор begin в блоке функции.  Если вы
        продолжаете нажимать F7,  строка выполнения перемещается по функ-
        ции,  а затем,  когда вы дойдете до оператора end, возвращается к
        оператору вызова.

             Формат вашей программы влияет на поведение строки выполнения
        при трассировке,  хотя и не в такой степени как при пошаговом вы-
        полнении. Если код сформатирован как в Примере 6.1, то трассиров-
        ка оператора for приводит к выполнению 10 раз функции Negate. Ес-
        ли вы разобъете оператор for на две строки, как в Примере 6.2, то
        трассировка оператора end функции возвращает строку выполнения ту
        строку основной программы,  которая будет выполняться  следующей.
        Первые девять  раз  это снова будет вызов функции.  В десятый раз
        строка выполнения перемещается на оператор end программы.



Трассировка или выполнение по шагам?

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

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

                   Примечание: О модулях и их секциях инициализации расс-
             казывается в Главе 7 "Модули Borland Pascal".

               Пошаговое выполнение и трассировка методов объектов

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

                Пошаговое выполнение и трассировка внешнего кода

             Если вы выполняете в программе компоновку с  внешним  кодом,
        используя для этого директиву компилятора {$L имя_файла}, то если
        компонуемый файл .OBJ содержит отладочную информацию,  вы  можете
        трассировать этот код или выполнять его по шагам.  Borland Pascal
        ничего не  знает об отлаживаемом вами коде в этих модулях,  но он
        будет показывать вам соответствующие строки в исходном коде.

                   Примечание: Требования к внешнему  коду  поясняются  в
              Главе 25 "Руководства по языку".

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




Выполнение больших фрагментов

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

             Чтобы задать в программе точку,  до которой вы хотите ее вы-
        полнить, а  затем  остановиться,  используйте  команду  Run|Go To
        Cursor (Выполнение|Выполнение до курсора) или клавишу  F4.  (Этим
        вы сообщите  отладчику,  что не хотите выполнять программу по ша-
        гам, пока не достигнете заданной точки.) Позиционируйте курсор на
        той строке,  где вы хотите возобновить управление отладкой, затем
        нажмите клавишу F4.  Заметим, что вы можете сделать это как в на-
        чале сеанса отладки, так и когда уже выполните часть программы по
        шагам или протрассируете.



Поиск нужного места

             IDE предусматривает два способа поиска в программе заданного
        места. Простейший способ предоставляет команда Find Procedure ме-
        ню Search. Команда Find Procedure (Поиск процедуры) запрашивает у
        вас имя процедуры  или  функции,  затем  находит  соответствующую
        строку в  файле,  где определяется эта подпрограмма.  Этот подход
        полезно использовать при редактировании,  но его можно комбиниро-
        вать с  возможностью  выполнения программы до определенной точки,
        чтобы пройти программу до той части кода, которую вы хотите отла-
        дить.

                                     Возврат

             Иногда в ходе отладки полезно узнать, как вы попали в данную
        часть кода. Окно Call Stack (Стек вызова) показывает вам последо-
        вательность вызовов процедур или функций, которые привели к теку-
        щему состоянию (глубиной до 128 уровней).  Для вывода  окна  Call
        Stack используйте команду Debug|Call Stack.

             Окно Call Stack особенно полезно использовать,  если вы слу-
        чайно начали трассировку кода,  который хотели  бы  выполнить  за
        один шаг.  В стеке вызовов вы можете найти тот вызов, который на-
        чали трассировать по ошибке, затем выбрать команду Run to Cursor,
        чтобы выполнить за один шаг остальную часть вызова.


Повторное выполнение

             В ходе сеанса отладки иногда желательно начать все  сначала.
        Выберите команду  Run|Reset  Program или нажмите клавиши Ctrl+F2.
        Это приведет к полному сбросу,  так что выполнение по шагам,  или
        трассировка начнется в начале основной программы.



Отслеживание вывода программы

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



Переключение экранов

             В любой момент сеанса отладки вы можете выполнять переключе-
        ние экрана IDE и экрана пользователя. Чтобы вывести экран пользо-
        вателя, нажмите клавиши Alt+F5.  Чтобы вернуться в  IDE,  нажмите
        любую клавишу или щелкните "мышью".

             При выполнении  программы  отладчик  также может переключать
        экраны автоматически.  Управлять характером переключения  экранов
        вы можете с помощью параметров Display Swapping (Переключение эк-
        рана) диалогового окна Debugger.  По умолчанию задано эффективное
        переключение.  Это  означает,  что  экран  пользователя выводится
        только в том случае, если выполняемый оператор выводит информацию
        на  экран  или вызывает процедуру (даже если эта процедура ничего
        на экран не выводит). После завершения вывода экран переключается
        обратно в IDE.

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



Окно Output

             IDE для DOS предусматривает для  экрана  пользователя  окно,
        которое называется  окном  вывода.  Выбрав  команду  меню  Debug|
        Output, вы можете открыть (вывести на  переднем  плане)  активное
        окно,  содержащее  вывод  программы.  Настроить размер этого окна
        можно аналогично окну редактирования.



Использование двух мониторов

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



Просмотр значений

             Выполнение программы по шагам или ее трассировка  могут  по-
        мочь вам найти ошибки в алгоритме программы, но обычно желательно
        также знать,  что происходит на каждом шаге со значениями отдель-
        ных переменных.  Например, при выполнении по шагам цикла for  по-
        лезно знать значение переменной цикла.  IDE Borland Pascal  имеет
        два инструментальных средства для проверки содержимого переменных
        программы: окно Watches (Просмотр) и диалоговое окно Evaluate and
        Modify (Вычисление и модификация).




Что такое выражение?

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

                          Элементы выражений отладчика        Таблица 6.1
        +--------------------------+------------------------------------+
        |    Элемент выражения     |      Допустимые значения           |
        +--------------------------+------------------------------------|
        | Константы                | Все допустимые типы: Boolean, Byte,|
        |                          | Char, перечислимый   тип,  Integer,|
        |                          | Longint,  Real,  Shortint,  Word  и|
        |                          | строковый тип.                     |
        +--------------------------+------------------------------------|
        | Переменные               | Все  типы, включая типы, определен-|
        |                          | ные пользователям.                 |
        |                          |                                    |
        |    целочисленный тип     | Любое целочисленное выражение с пе-|
        |                          | ременными границами диапазона.     |
        |                          |                                    |
        |    тип с плавающей точкой| Любые выражения с плавающей  точкой|
        |                          | или целочисленные выражения; лишние|
        |                          | значащие цифры отбрасываются.      |
        |                          |                                    |
        |    символьный тип        | Любое символьное выражение, включая|
        |                          | печатаемые символы  в одинарных ка-|
        |                          | вычках,  целочисленные   выражения,|
        |                          | тип которых приведен к типу Char, и|
        |                          | контанты ASCII (#xx).              |
        |                          |                                    |
        |    булевский тип         | True, False и все булевские выраже-|
        |                          | ния.                               |
        |                          |                                    |
        |    перечислимый тип      | Любые совместимые перечислимые кон-|
        |                          | станты или целочисленные  выражения|
        |                          | в  рамках  диапазона,  тип  которых|
        |                          | приведен к совместимому  перечисли-|
        |                          | мому типу.                         |
        |                          |                                    |
        |    указатель             | Любые совместимые указатели или вы-|
        |                          | ражения с приведенными к ним  типа-|
        |                          | ми;  функция  Ptr с соответствующим|
        |                          | параметрами.                       |
        |                          |                                    |
        |    строковый тип         | Любая строковая  константа (текст в|
        |                          | одинарных кавычках);  строковые пе-|
        |                          | ременные; строковые выражения, сос-|
        |                          | тоящие из конкатенированных строко-|
        |                          | вых констант и переменных.         |
        |                          |                                    |
        |    множество             | Любая множественная  константа; лю-|
        |                          | бое выражение,  совместимое  с мно-|
        |                          | жественным типа,  в котором исполь-|
        |                          | зуются операции +, - и *.          |
        +--------------------------+------------------------------------|
        | Приведение типа          | Соблюдаются   стандартные   правила|
        |                          | Паскаля.                           |
        +--------------------------+------------------------------------|
        | Операции                 | Все операции Borland Pascal.       |
        +--------------------------+------------------------------------|
        | Встроенные функции       | Все функции, допустимые в выражени-|
        |                          | ях-константах.                     |
        +--------------------------+------------------------------------|
        | Массивы                  | Массивы Borland Pascal - Mem, MemL,|
        |                          | MemW.                              |
        +--------------------------+------------------------------------+



Просмотр выражений

             Если вы хотите отслеживать значение переменной или выражения
        при выполнении  программы по шагам,  то можете открыть окно прос-
        мотра Watches. Это окно IDE показывает переменные и их значения в
        каждый конкретный момент.

             Чтобы открыть  окно Watches,  выберите команду Window|Watch.
        IDE открывает активное окно Watches без активных записей. Если вы
        выберите переменную  для  просмотра,  IDE автоматически открывает
        окно Watches (если вы этого еще не сделали).

                      Добавление просматриваемого выражения

             Чтобы добавить в окно Watches переменную,  выберите  команду
        Debug|Watch|Add Watch  или  нажмите  клавиши  Ctrl+F7.  Если окно
        Watches является активным окном,  вы  можете  добавить  выражение
        просмотра, нажав клавишу Ins. Отладчик открывает диалоговое окно,
        запрашивающее у вас тип просматриваемого выражения.  По умолчанию
        выражением считается  слово  в позиции курсора в текущем окне ре-
        дактирования. Просматриваемые выражения,  которые вы  отслеживали
        ранее, сохраняются в списке протокола.

                Отслеживание текущего просматриваемого выражения

             Последнее добавленное  или  модифицированное просматриваемое
        выражение является текущим  просматриваемым  выражением,  которое
        указывается выводимым  слева от него символом жирной левой точки.
        Если окно Watches активно,  вы можете также удалить текущее выра-
        жение, нажав клавишу Del или Ctrl+Y. Чтобы удалить все просматри-
        ваемые выражения,   выберите   команду   Debug|Watch|Remove   All
        Watches.

                    Редактирование просматриваемых выражений

             Чтобы отредактировать просматриваемое выражение, нужно дваж-
        ды щелкнуть на этом выражении "мышью" или сделать  это  выражение
        текущим, затем  нажать  клавишу  Enter или выбрать команду Debug|
        Watch|Edit Watch. Отладчик открывает диалоговое окно, аналогичное
        тому, которое  используется для добавления просматриваемого выра-
        жения, которое позволяет вам отредактировать  текущее  выражение.
        При выборе командной кнопки OK или нажатии клавиши Enter отредак-
        тированное выражение заменяет оригинал.

                    Форматирование просматриваемых выражений

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



Спецификаторы формата в выражениях отладчика
                                                            Таблица 6.2
        +--------------+---------------------+--------------------------+
        |  Символ      |    Тип, на который  |         Функция          |
        |              |       он влияет     |                          |
        +--------------+---------------------+--------------------------|
        |  $, H или X  | целочисленные типы  | Шестнадцатиричный.  Выво-|
        |              |                     | дит целочисленные  значе-|
        |              |                     | ния в префиксом $,  вклю-|
        |              |                     | чая те, которые содержат-|
        |              |                     | ся в структуре данных.   |
        +--------------+---------------------+--------------------------|
        |  C           | Char, строковые     | Символьный.  Выводит спе-|
        |              | типы                | циальные  символы для ко-|
        |              |                     | дов ASCII 0..31. По умол-|
        |              |                     | чанию такие символы выво-|
        |              |                     | дятся  в  виде   значений|
        |              |                     | #xx.                     |
        +--------------+---------------------+--------------------------|
        | D            | целочисленные       | Десятичный. Выводят цело-|
        |              | типы                | численные  значения в де-|
        |              |                     | сятичном виде    (включая|
        |              |                     | те,  которые содержатся в|
        |              |                     | структурах данных).      |
        +--------------+---------------------+--------------------------|
        | Fn           | с плавающей точкой  | С плавающей точкой. Выво-|
        |              |                     | дит n значащих цифр,  где|
        |              |                     | n лежит в диапазоне 2..18|
        |              |                     | (по умолчанию - 11).     |
        +--------------+---------------------+--------------------------|
        | nM           | все                 | Дамп  памяти.  Выводит  n|
        |              |                     | байт памяти,   начиная  с|
        |              |                     | адреса,  указываемого вы-|
        |              |                     | ражением. Если n не зада-|
        |              |                     | но,  то по умолчанию  оно|
        |              |                     | равно  значению размера в|
        |              |                     | байтах типа переменной.  |
        +--------------+---------------------+--------------------------|
        | P            | указатели           | Указатель. Выводит указа-|
        |              |                     | тели по  адресу сегм:смещ|
        |              |                     | (на  не   Ptr(сегм:смещ),|
        |              |                     | как это делается по умол-|
        |              |                     | чанию.                   |
        +--------------+---------------------+--------------------------|
        | R            | записи, объекты     | Запись. Выводит имена по-|
        |              |                     | лей, например,      (X:1;|
        |              |                     | Y:10; Z:5) вместо (1, 10,|
        |              |                     | 5).                      |
        +--------------+---------------------+--------------------------|
        | S            | Char, строки        | Строки.  Выводит  символы|
        |              |                     | ASCII 0..31  в  виде #xx.|
        |              |                     | Использует только для мо-|
        |              |                     | дификации  дампов  памяти|
        |              |                     | (см. выше nM).           |
        +--------------+---------------------+--------------------------+





Вычисление и модификация

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

                              Вычисление выражений

             Чтобы вычислить выражение,  выберите команду Debug|Evaluate/
        Modify или  нажмите клавиши Ctrl+F4.  Отладчик выводит диалоговое
        окно Evaluate and Modify (Вычисление и модификация). По умолчанию
        слово в  позиции  курсора в текущем окне редактирования выводится
        подсвеченным в поле Expression (Выражение).  Вы можете отредакти-
        ровать это выражение, набрать другое выражение или выбрать вычис-
        ляемое вами ранее выражение из списка протокола.

             Когда вы нажимаете Enter или щелкаете "мышью"  на  командной
        кнопке Evaluate, текущее значение выражения в поле Expression по-
        казывается в поле Result.

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

                             Модификация переменных

             Во время  отладки  с  помощью  диалогового окна Evaluate and
        Modify вы можете изменить значение переменной. Введите переменную
        в поле Expression, затем в поле New Value наберите новое значение.

             При изменении  значений переменных следует иметь в виду сле-
        дующее:

             * Вы можете изменять только отдельные переменные или элемен-
               ты массивов или записей, но не сами массивы и записи.

             * Выражения  в  поле  New Value должны отвечать ограничениям
               для выражений, перечисленных в Таблице 6.1.

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



Использование точек останова

             Borland Pascal дает вам  возможность  устанавливать  в  свое
        программе для целей отладки точки останова.  Точка останова - это
        обозначенная в коде программы позиция,  в которой вы хотите прек-
        ратить выполнение  программы  и  вернуть выполнение отладчику.  В
        этом смысле точка останова  работает  аналогично  команде  Go  to
        Cursor, при которой программа выполняется обычным путем до дости-
        жения определенной точки. Основное различие состоит в том, что вы
        можете задать несколько точке останова и точки останова,  которые
        будут срабатывать не при каждом их достижении.


Задание точек останова

             Чтобы установить в своем в своем коде точку останова,  пере-
        местите курсор на той строке,  где вы хотите остановиться. Строка
        должна содержать  выполняемый  код  и не может быть комментарием,
        описанием или пустой строкой.  Выбор команды Toggle Breakpoint  в
        локальном меню окна редактирования или нажатие клавиш Ctrl+F8 ус-
        танавливает на строке точку останова,  которая обозначается подс-
        веткой всей строки.

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



Отмена точке останова

             Чтобы отменить точку останова,  поместите курсор на содержа-
        щую ее строку и выберите в локальном меню окна редактирования ко-
        манду Toggle Breakpoint или нажмите клавиши Ctrl+F8.



Модификация точек останова

             В процессе сеанса отладки IDE отслеживает все точки  остано-
        ва. Вместо  того,  чтобы  шарить по исходному коду в поиске точек
        останова, она обслуживать точки останова в одном диалоговом  окне
        Breakpoints. Для вывода диалогового окна Breakpoints выберите ко-
        манду View|Breakpoints. В этом диалоговом окне вы можете устанав-
        ливать, удалять, редактировать и просматривать свои точки остано-
        ва.

             Командные кнопки диалогового окна Breakpoints работают  сле-
        дующим образом:

             * Чтобы  добавить  новую  точку останова,  подсветите пустую
               строку в списке и выберите командную кнопку Edit.

             * Чтобы отменить точку останова,  подсветите ее  и  выберите
               кнопку Clear.

             * Чтобы модифицировать существующую точку останова,  подсве-
               тите ее и выберите командную кнопку Edit.

             * Чтобы найти в своем исходном коде точку останова,  подсве-
               тите ее и выберите кнопку View.

             * Чтобы удалить все точки останова, выберите командную кноп-
               ку Clear All.



Создание условный точек останова


             Точки останова,  добавленные командой Toggle Breakpoint, яв-
        ляются безусловными: когда вы попадаете на эту строку, отладчик в
        любом случае останавливает программу.  Если вы редактируете новую
        или существующую точку останова, то у вас есть две дополнительные
        возможности -  с  помощью  параметров   диалогового   окна   Edit
        Breakpoint вы можете создать условные точки останова. В этих точ-
        ках останова вы можете задать два вида условий:  счетчик проходов
        и логические условия.

                              Подсчет числа проходов

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

                                Проверка условий

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



Прерывание программы без точек останова

             Даже если вы не установите точек останова, то все равно смо-
        жете выйти  в  отладчик при выполнении программы из IDE.  В любой
        момент работа программы нажмите клавиши Ctrl+Break.  Отладчик на-
        ходит позицию в исходном коде, где вы прервали программу. Как и в
        случае обычно точки останова вы можете затем выполнить  программу
        по шагам, трассировать ее, отследить или вычислить выражения.
                              Назад | Содержание | Вперед

Обратная связь
Информация для авторов

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

Источник