Ключевой момент: ошибки программирования можно разделить на три типа: синтаксические ошибки, ошибки во время выполнения и логические ошибки.
Ошибки,
допускаемые при написании программ,
разделяют на синтаксические и логические.
Синтаксические
ошибки —
нарушение формальных правил написания
программы на конкретном языке,
обнаруживаются на этапе трансляции и
могут быть легко исправлены.
Программа,
содержащая синтаксическую ошибку, не
может быть запущена. При попытке ее
компиляции выдается сообщение, обычно
содержащее указание того места в тексте,
«дочитав» до которого, компилятор
заметил ошибку; сама ошибка может быть
как в этом месте, так и выше него (часто
— в предыдущей строке).
Логические
ошибки
делят на ошибки алгоритма и семантические
ошибки — могут быть найдены и исправлены
только разработчиком программы.
Причина
ошибки алгоритма — несоответствие
построенного алгоритма ходу получения
конечного результата сформулированной
задачи.
Причина
семантической ошибки — неправильное
понимание смысла (семантики)
операторов языка.
Программа,
содержащая логическую ошибку, может
быть запущена. Однако она либо выдает
неверный результат, либо даже завершается
«аварийно» из-за попытки выполнить
недопустимую операцию (например, деление
на 0) — в таком случае выдается сообщение
об ошибке
времени выполнения.
Поиск места в программе, содержащего
логическую ошибку, является непростой
задачей; он носит название отладки
программы.
Основные типы данных
Данные
в языке Си разделяются на две категории:
простые (скалярные), будем их называть
базовыми, и сложные (составные) типы
данных.
Основные
типы базовых данных: целый – int,
вещественный с одинарной точностью –
float
и
символьный – char.
В
свою очередь, данные целого типа могут
быть короткими – short,
а также длинными – long
и еще более длинными — long
long.
Кроме того, при любой длине данные целых
и символьного типов могут быть знаковыми
— signed
либо беззнаковыми – unsigned
(по
умолчанию они считаются знаковыми,
поэтому слово signed
необязательно и обычно опускается).
Вещественные же данные могут иметь
удвоенную точность – double
или
еще большую точность — long
double.
В
языке С++ введен также логический тип
bool.
Данные этого
типа могут принимать лишь два значения:
true
(истина) и false
(ложь).
Сложные
типы данных – массивы, структуры –
struct,
объединения или смеси – union.
Данные
целых и вещественных типов находятся
в определенных диапазонах, т.к. занимают
разный объем оперативной памяти.
Вещественные типы при этом обладают
еще конечной
точностью хранения данных,
т.е. верно хранят лишь первые несколько
цифр числа; для хранения остальных (чье
количество бывает даже бесконечным —
например, у числа π , или у числа ⅓ ) не
хватает места. В Табл. 1. приведены
свойства различных типов для системы
программирования C++
Builder.
В других системах программирования,
поддерживающих язык Си, может отличаться
размер того или иного конкретного типа,
например int,
и соответственно будет отличаться его
допустимый диапазон значений (например,
тип long
int
может превосходить по размеру тип int).
Однако последовательность возрастания
размеров и точности для каждой группы
типов всегда одинакова:
char
≤
short int ≤
int ≤
long int ≤
long long int
float
≤
double ≤
long double
Заметим,
что для целочисленных типов данных, чье
название содержит слово int
и еще какое-либо слово перед ним, слово
int
можно не писать, и обычно оно опускается
(в Табл.1 необязательное int
указано мелким шрифтом).
Отладка программы призвана выискивать «вредителей» кода и устранять их. За это отвечают отладчик и журналирование для вывода сведений о программе.
В предыдущей части мы рассмотрели исходный код и его составляющие.
После того, как вы начнете проверять фрагменты кода или попытаетесь решить связанные с ним проблемы, вы очень скоро поймете, что существуют моменты, когда программа крашится, прерывается и прекращает работу.
Это часто вызвано ошибками, известными как дефекты или исключительные ситуации во время выполнения. Акт обнаружения и удаления ошибок из нашего кода – это отладка программы. Вы лучше разберетесь в отладке на практике, используя ее как можно чаще. Мы не только отлаживаем собственный код, но и порой дебажим написанное другими программистами.
Для начала необходимо рассортировать общие ошибки, которые могут возникнуть в исходном коде.
Синтаксические ошибки
Эти эрроры не позволяют скомпилировать исходный код на компилируемых языках программирования. Они обнаруживаются во время компиляции или интерпретации исходного кода. Они также могут быть легко обнаружены статическими анализаторами (линтами). Подробнее о линтах мы узнаем немного позже.
Синтаксические ошибки в основном вызваны нарушением ожидаемой формы или структуры языка, на котором пишется программа. Как пример, это может быть отсутствующая закрывающая скобка в уравнении.
Семантические ошибки
Отладка программы может потребоваться и по причине семантических ошибок, также известных как логические. Они являются наиболее сложными из всех, потому что не могут быть легко обнаружены. Признак того, что существует семантическая ошибка, – это когда программа запускается, отрабатывает, но не дает желаемого результата.
Рассмотрим данный пример:
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 обычно вызваны тем, что ваш исходный код использует слишком много ресурсов. Хорошее знание алгоритмов поможет написать код, который лучше использует ресурсы. В этом и заключается отладка программы.
Процесс перезаписи кода для повышения производительности называется оптимизацией. Менее популярное наименование процесса – рефакторинг. Поскольку вы тратите больше времени на кодинг, то должны иметь это в виду.
Отладка программы
Вот несколько советов о том, как правильно выполнять отладку:
Двигаемся дальше
Поздравляем! Слово «ошибка» уже привычно для вас, равно как и «отладка программы». В качестве новичка вы можете изучать кодинг по книгам, онлайн-урокам или видео. И даже чужой код вам теперь не страшен 🙂
В процессе кодинга измените что-нибудь, чтобы понять, как он работает. Но будьте уверены в том, что сами написали.
Викторина
input = Hippo’
if input == ‘Hippo’:
print ‘Hello, Hippo’
Ответы на вопросы
2. Синтаксическая ошибка: Отсутствует стартовая кавычка в первой строке.
Как было показано
в предыдущем разделе на примере программы,
преобразующей
массив целых чисел,
приложение может
собираться и работать,
но не выполнять
полностью того,
что ему полагается
делать. Это
означает, что
текст программы не соответствует
спецификации поставленной задачи и
содержит логическую ошибку,
а возможно,
сразу и несколько
логических ошибок.
Из всех категорий
ошибок логические ошибки найти наиболее
трудно, так
как они берут свое начало в ошибочном
рассуждении при поиске решения задачи.
Такие ошибки
обнаруживаются на этапе выполнения
программы и приводят к неверным
результатам, к
остановке или «зависанию»
приложения.
Это делает
необходимым тестирование приложения
с различными наборами данных.
Только тщательное
тестирование на самых разнообразных
значениях данных может дать на практике
гарантию того,
что приложение
не содержит логических ошибок.
Самым простым
способом локализации логической ошибки
является пошаговое прослеживание
результатов выполнения всех операторов
программы. При
отладке приложения в VS
можно отображать
значения указанных переменных или
выражений в любой точке программы.
Вычисленные значения
можно, сравнивать с теми, что должны
быть, и если обнаруживается несоответствие,
то, логическая ошибка локализована.
Первый шаг отладки
приложения – это выбор команды Start
Debugging
(F5) на стандартной
панели инструментов или в меню Debug,
после чего приложение запускается в
режиме отладки.
Перед началом отладки
целесообразно определить то место в
программе, где возможна ошибка. Это, как
правило, позволяет существенно сократить
время, затрачиваемое на поиски ошибки.
В примере 2 ошибка может содержаться в
том фрагменте программы, который изменяет
значения элементов массива после их
ввода с клавиатуры.
Для того чтобы
отладчик прерывал выполнение программы
на определенной строке, необходимо
установить на этой строке точку
останова.
Точка останова
– это просто
место (например, строка с оператором
программы), которое помечено для отладчика
и отображается красным кружком в поле
индикаторов (узкое
поле серого цвета с левого края окна
редактора кода). Когда отладчик встречает
точку останова, то выполняющаяся
программа моментально останавливается
(до выполнения данной строки кода).
Установить точку
останова на какой-либо строке кода можно
при помощи щелчка по полю индикаторов
данной строки (рис. 16). Либо можно
установить курсор на нужной строке и
нажать клавишу F9.
Просмотр
данных в отладчике
Когда выполнение
программы в сеансе отладки приостановлено
(например,
при помощи точки
останова), можно
изучить состояние и содержимое ее
переменных и объектов.
Для этого в VS
можно использовать
три вида окон:
Local
(Локальные),
Autos
(Видимые)
и Watch
(Контрольные).
Рисунок 17. Доступ к
окнам
Окно Local
показывает
все переменные и их значения для текущей
области видимости отладчика.
Это дает вам
представление обо всем,
что имеется в
текущей выполняющейся функции.
Переменные в
этом окне организованы в список и
автоматически настраиваются отладчиком.
На рис.
18 показан пример
окна Local.
С его помощью
можно увидеть приложение нашего примера,
которое
приостановлено до обнуления соответствующих
элементов массива.
Обратите внимание,
что объект
(массив)
a
развернут для
того, чтобы
показать значения его элементов в момент
остановки выполнения программы.
По мере установки
значений результаты будут отображаться
в столбце Value.
Однако очень часто
просмотр всех локальных переменных
дает слишком много информации, чтобы в
ней можно было разобраться. Так может
происходить тогда, когда в области
видимости данного процесса или функции
находится слишком много операторов.
Для того
чтобы увидеть
значения, связанные с той строкой кода,
на которую вы смотрите, можно использовать
окно Autos.
Это окно показывает значения всех
переменных и выражений, имеющихся в
текущей выполняющейся строке кода или
в предыдущей строке кода. На рис. 19
показано окно Autos
для той же
самой строки кода, которая показана на
рис. 18. Обратите внимание на разницу.
Окна Watch
в VS позволяют
настраивать собственный список переменных
и выражений, за которыми нужно наблюдать
(рис. 20). Окна Watch
выглядят и
ведут себя точно так же, как и окна Local
и Autos.
Кроме того, те элементы, которые вы
размещаете в окнах Watch,
сохраняются между сеансами отладки.
Вы получаете доступ
к окнам Watch
из меню или панели инструментов Debug
(рис. 17).
Четыре окна Watch
(которые называются Watch
1, Watch
2, Watch
3 и Watch
4) позволяют
настроить четыре списка элементов, за
которыми необходимо наблюдать. Эта
возможность может быть особенно полезна
в том случае, когда каждый список
относится к отдельной области видимости
вашего приложения.
Переменную или
выражение в окно Watch
1 можно добавить
из редактора кода. Для этого в редакторе
кода выделите переменную (или выражение),
щелкните по ней правой кнопкой мыши и
выберите пункт Add
Watch.
При этом выделенная переменная (или
выражение) будет помещена в окно Watch
1. Вы можете
также перетащить выделенный элемент в
это окно.
Пошаговое
прохождение для поиска ошибки
После того как в
нашем примере отладчик,
встретив точку
останова, прервал
выполнение программы,
далее можно
выполнять код по шагам (режим
трассировки).
Для этого можно
выбрать команду Step
into
на панели
инструментов Debug
или нажать
функциональную клавишу F11(Рис.
21). Это приведет
к последовательному выполнению кода
по одной строке,
что позволит
вам видеть одновременно и ход выполнения
приложения, и
состояние объектов программы по мере
выполнения кода.
Команда Step
into
(F11) позволяет
продвигаться по коду по одной строке.
Вызов этой
команды выполнит текущую строку кода
и поместит курсор на следующую выполняемую
строку. Важное
различие между Step
into
и другими
похожими командами состоит в
том,
как Step
into
обрабатывает
строки кода, в
которых содержатся вызовы функций.
Если вы находитесь
на строке кода,
которая вызывает
другую функцию программы,
то выполнение
команды Step
into
перенесет вас
на первую строку этой функции.
Если сделать так в
нашем примере,
то вы увидите
ошибку: обнуление
элементов массива должно начинаться
не с элемента с индексом i1,
а со следующего
элемента i1+1.
Команда Step
out
(F10) позволяет
вам сохранять фокус в текущей функции
(не заходя в вызываемые ею подпрограммы),
т. е. вызов Run
out
приведет к
выполнению строки за строкой, но не
заведет вас в вызовы функций и при этом
следующей выполняемой
строкой для пошагового
прохождения станет следующая за вызовом
функции строка.
Рис 21. Команда Step
Into
Одной из более
удобных (и
часто упускаемых)
функциональных
возможностей набора инструментов
отладки является функция Run
to
cursor
( Выполнить до текущей позиции).
Она работает в
полном соответствии со своим названием.
Вы устанавливаете
курсор на некий код и вызываете эту
команду. Приложение
компилируется и выполняется до тех пор,
пока не доходит
до той строки,
где находится
курсор. В
этой точке отладчик прерывает приложение
и выдает вам эту строку кода для пошагового
прохождения.
Рис. 22.
Рисунок 22. Вызов
команды Run
To
Cursor
Продолжить отладку
после точки останова можно повторным
нажатием на кнопку F5 (Start
Debugging).
Рисунок 23. Результат
работы программы после исправления
ошибки
Рассмотрим пошаговое
выполнение программы с использованием
окна Watch
на простейшем примере.
Рисунок 24. Окно
редактора кода в начале трассировки.
Рисунок 25. Значение
переменных перед первым прохождением
цикла
Рисунок 26. Окно
редактора кода перед первым прохождением
цикла
Рисунок
27. Значения переменных после выполнения
операции а=а+1
Рисунок
28. Значения переменных после выполнения
операции b=b+2
Рисунок
29. Значения переменных после выполнения
операции S=(S*a)+(S/b)
Рисунок
30. Значения переменных после выполнения
операции i++
Рисунок
31. Значения переменных после прохождения
цикла
Рисунок 32. Вывод
итогового значения на экран
Первые ошибки и их исправление
Error 85: «;»
expected.
(Ошибка 85: «;»
отсутствует.)
Редактор
установит курсор на следующий символ
после пропущенного знака, в нашем
примере на переменную b. После нажатия
любой клавиши, сообщение об ошибке
исчезает и редактор переходит в режим
вставки. Надо подвести курсор к нужному
месту, поставить точку с запятой — “;”
и продолжить работу.
2.
В описании переменных не записана
переменная, а в программе она присутствует,
например переменная c. После пуска
программы, будет выдано сообщение:
Error 3: Unknown identifier.
(Ошибка 3: Неизвестный
идентификатор.)
Курсор
будет установлен на эту переменную, в
нашем примере на переменную c. Надо
исправить ошибку, т.е. записать переменную
c в раздел описаний переменных и продолжить
работу.
3.
Не поставлена точка после оператора
end в конце программы. Сообщение компилятора
будет таким:
Error 10: Unexpected end of
file.
(Ошибка 10: Неправильный
конец файла.),
курсор
установится на букву «e» в слове
«end». Надо поставить точку и снова
выполнить программу.
В Турбо Паскаль
имеется справочная служба, охватывающая
все возможные вопросы по написанию
программ. Главное – это подсказки по
ключевым словам языка.
CONTENTS.
Выводит на экран содержание справочной
службы.
INDEX.
Выводит на экран алфавитный список всех
ссылок справочной службы. Вызывается
из редактора командой Shift-F1.
TOPIC
SEARCH.
Осуществляет поиск в окрестности курсора
зарезервированного слова или имени
стандартной процедуры (функции) и дает
соответствующую справку. Вызывается
из редактора командой Ctrl-F1.
PREVIOUS
TOPIC.
Выводит на экран предыдущее справочное
сообщение. Вызывается из редактора
командой Alt-F1.
HELP
ON
HELP.
Дает справку о том, как пользоваться
справочной службой. Отметим, что в
сообщениях справочной службы все
перекрестные ссылки выделяются цветом.
Вы можете подвести к любой из них
указатель мыши и двойным нажатием на
ее левую кнопку вызвать на экран
соответствующее справочное сообщение
(или сместить к ней указатель с помощью
клавиш перевода курсора и нажать Enter).
FILES.
С помощью этой опции Вы можете установить
нужные файлы справочной службы.
COMPILER
DIRECTIVES.
Показывает справку о директивах
компилятора.
RESERVED
WORDS.
Показывает справку о зарезервированных
словах.
STANDARD
UNITS.
Показывает справку о стандартных
модулях.
TURBO
PASCAL
LANGUAGE.
Показывает справку о языке Турбо Паскаль.
ERROR
MESSAGES.
Показывает справку о сообщениях об
ошибках.
ABOUT.
Выводит информацию об авторских правах
и версии Турбо Паскаля.
Лекция №7
Процедуры. Программирование рекурсивных
алгоритмов.
Программист
должен видеть в целом программу, которая
решает какую-то задачу, а потом разбивает
ее на отдельные части, составляет на
выбранном языке программирования эти
части программы, объединяет их в единое
целое и получает программу.
Итак,
весь творческий процесс можно разбить
(разумеется, чисто условно) на следующие
этапы:
1) основная идея
решения задачи;
2) общая конструкция
программы;
3)
выделение отдельных, элементарных
частей программы;
4)
практическая реализация на языке
программирования этих частей программы;
5)
объединение их в единую программу.
Такой
процесс программирования называют
структурным или нисходящим. Более
подробно с этим процессом мы познакомимся
позже, когда изучим хотя бы основы языка
программирования, но об отдельных
частях, «кирпичиках», составляющих
программу узнаем на этом занятии.
Подпрограммой
называется группа операторов, к которой
обращаются из основной программы
несколько раз. Иногда это может быть 2,
3 раза, а очень часто, каждый раз из
выполняемого цикла основной программы.
Вполне
понятно, что писать несколько раз
одинаковые группы операторов трудно,
проделывается много «технической»
работы, а в некоторых случаях просто
невозможно (если обращаться приходиться
каждый раз при выполнении цикла).
Для
облегчения такой работы и созданы
подпрограммы.
1)
сделать основную программу более
наглядной и компактной;
2) уменьшить объем
используемой памяти ЭВМ;
3) сократить время
отладки программы.
На
языке Паскаль подпрограммы
бывают двух видов, — это процедуры и
функции.
Рассмотрим
следующий простой пример, с помощью
которого попробуем разобраться в
конструкции процедур на Паскале.
Пример.
Составить программу, которая бы проверяла,
являются ли три числа взаимно простыми.
Мы
знаем, что числа называются взаимно
простыми, если их наибольший общий
делитель (НОД) равен 1. Значит, для решения
этой задачи нам придется дважды находить
НОД чисел. Если заданы три числа: a, b, c,
то найти НОД(a, b), а затем найти НОД(НОД(a,
b), c).
Дважды
писать операторы для нахождения НОД
нам не хочется, поэтому оформим операторы
для НОД в виде процедуры.
Посмотрите,
как это будет выглядеть в программе:
a, b, c, k : integer;
Procedure nod(a, b :
integer; var n : integer);
r := a mod b;
a := b; b := r
until
b = 0;
n := a
write(‘Введите
три натуральных числа ‘); readln(a,
b,
c);
a
:= k;
b
:= c;
if
k
= 1 then
writeln(‘Числа
взаимно простые’)
else
writeln(‘Числа не взаимно простые’)
В
разделе описаний, после описания
переменных, записывается заголовок
процедуры: Procedure
Это
слово является служебным и зарезервировано
в Паскале. В одной строке с ним, через
пробел, записывается имя процедуры,
которое должно удовлетворять всем
требованиям, предъявляемым к именам,
основными из которых являются: начинаться
с буквы и не иметь пробелов, т. е.,
требования такие же, как и к имени
программы (имя нашей процедуры — nod):
Procedure
nod(a,
b
: integer;
var
n
: integer);
Далее,
в скобках, записываются имена переменных
и их типы, значения которых будут
вводиться
в процедуру из основной программы, в
нашем случае, их две (a, b) и они имеют тип
integer.
Сразу
надо заметить, что имена этих переменных
могут не совпадать с именами переменных
в основной программе, скажем мы могли
их обозначить m, n или любыми другими
именами.
После
точки с запятой и зарезервированного
слова var, записываются переменные и их
типы, значения которых будет являться
результатом работы процедуры и выводятся
из нее в основную программу. Такая
переменная в нашем примере одна — n. Она
выведет значение НОД чисел a и b. Ее имя
также может иметь одноименное в основной
программе и это нисколько не отразится
на работе процедуры.
Обратите
внимание,
что перед переменными, значения которых
вводятся
из основной программы, не ставится слово
var, а перед переменной, значение которой
выводится
в основную программу, это слово записано.
Это очень важное обстоятельство!
Так,
если поставить var перед a и b, то компилятор
будет воспринимать эти переменные как
выходные и вводимые для них значения
воспринимать не будет, и, наоборот, если
var не будет записано перед выходной
переменной, то компилятор воспримет ее
как входную и выводить ее значение в
основную программу не будет.
Дальнейшее
построение процедуры строится также,
как и основная программа на Паскале.
Описываются
переменные, которые будут участвовать
в ее работе, но их имена не должны
повторять имена уже описанных входных
и выходных параметров в заголовке
программы. Далее описываются необходимые
для работы операторы.
В
нашем примере процедура
nod будет такой:
Procedure
nod(a, b : integer; var n : integer);
Основная
программа строится обычным образом, но
там, где необходимо найти НОД чисел,
обращается к процедуре. Как?
Для
этого обращаются к ней по имени, а в
скобках записывают фактические значения
входных переменных (в нашем случае для
переменных a и b), а также имена выходных
переменных (в нашем случае k).
Из
приведенного ниже участка программы
видно, что при первом обращении к
процедуре nod определяется НОД чисел a и
b (nod(a, b, k)) и результат запоминается в
переменную k, далее, изменяются значения
переменных a и b
и снова вызывается процедура nod, которая
уже находит НОД чисел k и c и результат
присваивает переменной k.
Вы можете видеть
основную часть программы:
write(‘Введите
три натуральных числа ‘); readln(a, b, c);
Сделаем
общие выводы для построения и работы
процедур
Процедуры
помещаются в разделе описаний и начинается
зарезервированным (служебным) словом
Процедуре
обязательно
дается имя, которое должно удовлетворять
тем же требованиям, что и имена переменных,
т.е. это может быть одна или несколько
букв, комбинация букв и целых чисел, но
без пробелов, начинаться с буквы и т.д.
После
имени, в скобках записываются переменные
— параметры и их тип: входные, значения
которых используются для вычисления в
качестве аргументов.
Выходные
параметры — это те переменные, в которых
получается результат выполнения
процедуры.
Входные
и выходные параметры процедуры называются
формальными
параметрами.
Фактические,
конкретные, значения формальные параметры
должны получить в основной программе
после обращения к ней (а пока в процедуре
они являются не чем иным, как «пустышками»).
После
формальных параметров, описываются
переменные, которые необходимы
непосредственно для работы процедуры.
Это
параметры
процедуры.
Они нужны в ней, как и в любой другой
программе и описываются также. Их имена
должны отличаться от имен входных и
выходных параметров.
Надо
заметить, что процедура может быть
такой, что в ней не будет вообще параметров,
достаточно тех, которые будут введены
из программы.
Описание процедуры
имеет вид:
Она
помещается в основной программе в
разделе описаний.
По
входным и выходным параметрам процедуры
могут быть следующих типов:
1)
иметь и
входные и выходные параметры:
Мы только
познакомились с программой такого типа.
2)
иметь входные параметры, но не иметь
выходных:
3)
иметь выходные
параметры, но не иметь входных:
4)
не иметь ни
входных, ни выходных параметров:
В
зависимости от этого различаются
процедуры по своей конструкции и
выполняемым функциям.
Далее
следует раздел операторов, который
составляется по тем же правилам, как и
в других программах.
Процедура
описана и после этого начинается основная
программа.
Как происходит
вызов подпрограммы — процедуры?
Обязательно
указывается имя процедуры. В скобках
задаются фактические
значения входных параметров и те
переменные, в которые будут «запоминаться»
выходные значения.
Рассмотрим
пример, где может быть использована
процедура второго типа: имеет входные
параметры, но не имеет выходных.
Процедуру
составим по следующему способу. Пусть
задано число n. Нам необходимо найти
такие два числа a и b, чтобы сумма их
квадратов была равна n, т.е. решить в
целых числах уравнение:
Чтобы
выяснить этот вопрос, можно организовать
цикл, в
котором проверять сколько чисел a надо,
чтобы выполнялось неравенство:
Здесь, в качестве b взято наименьшее
натуральное число 1. Организовав такой
цикл, и подсчитав, сколько чисел a
потребуется, мы узнаем сколько чисел
надо просматривать, чтобы найти решение
уравнения.
Этот цикл может
быть таким:
a
:= 1; k := 1;
while
a*a + 1<=n do
k
:= k + 1;
a
:= a + 1
Теперь ясно, что
для испытания чисел, следует устроить
цикл от 1 до k:
for a := 1 to k do
Второй
цикл должен
быть для значений b. Но если его организовать
тоже от 1 до k, тогда могут повторяться
дважды одинаковые значения, только на
разных местах, например, для числа 20
могут быть выданы следующие значения:
22
+ 42
= 20 и 42
+ 22
= 20.
Чтобы
избежать повторения чисел, цикл для
чисел b можно организовать либо от 1 до
a, либо от k до а.
Нами выбран первый
вариант.
Procedure to_square(n :
integer);
a, b, k : integer;
a := 1; k := 1;
while a*a + 1<=n
do
k := k + 1;
a := a + 1
for b := 1 to a do
if a*a + b*b =
n
writeln(n,
‘=’, a, ‘*’, a,’ +’, b, ‘*’, b); goto 1
Процедура
выполнена с досрочным прерыванием
цикла, так как нет необходимости выяснять
всевозможные значения пар чисел,
удовлетворяющих этому уравнению, а
достаточно просто выяснить возможность
такого представления.
Выполнив
такую процедуру, не составляет труда
решить полностью задачу. Для этого в
основной программе выполнить цикл для
всех чисел из промежутка, и каждое из
которых, с помощью процедуры проверять.
Кстати говоря, эта процедура имеет
только один формальный
параметр —
входной,
— значение проверяемого числа из
промежутка и не имеет выходных параметров.
a, b, i : integer;
a,
b, k : integer;
while a*a + 1 <=
n do
for b := 1 to a
do
writeln(n,
‘=’, a, ‘*’, a, ‘+’, b,’*’, b); goto 1
write(‘Введите конец
промежутка ‘); readln(b);
write(‘Числа,
которые можно представить в виде суммы
‘);
for i := a to b do
to_square(i);
Ошибки во время выполнения
Ошибки во время выполнения – это ошибки, которые приводят к ненормальному обрывы работы программы. Они возникают во время работы программы, если среда обнаруживает операцию, которую невозможно выполнить. Обычно ошибки ввода становятся причинами ошибок во время выполнения. Ошибки ввода возникают, когда программа ожидает от пользователя ввода значения, но пользователь вводит величину, которую программа не может обработать. Например, программа ожидает получение числа, но вместо этого пользователь вводит строку, это приводит к ошибкам в программе, связанным с типами данных.
Другой пример ошибок во время выполнения – это деление на ноль. Это происходит, когда в целочисленном деление делитель равен нулю. Пример программы, которая вызовет ошибку во время выполнения:
Выполнение программы. Ключевые кнопки
После
того, как программа набрана, можно
попробовать ее выполнить.
Если
не было ошибки при вводе текста, то,
спустя несколько секунд, произойдет
смена изображения на экране. Турбо
Паскаль предоставляет экран в распоряжение
работающей программы пользователя.
Такой экран называется окном
программы.
После
завершения прогона (работа программы
часто называется ее прогоном) на экране
вновь появится окно редактора с
текстом программы. Если Вы не успели
разглядеть изображение окна программы,
то нажмите Alt-F5. При этом окно редактора
скроется
и вы сможете увидеть результаты работы
программы. Чтобы вернуть экран в режим
воспроизведения окна редактора, надо
нажать на любую клавишу.
Распространённые ошибки
Пропуск закрывающей фигурной скобки, пропуск точки с запятой, пропуск кавычки для строки и неправильное написание имён – всё это самые распространённые ошибки для новых программистов.
Частые ошибки 1: Пропущенные фигурные скобки
Фигурные скобки используются для обозначения в программе блоков. Каждой открывающей фигурной скобке должна соответствовать закрывающая фигурная скобка. Распространённая ошибка – это пропуск закрывающей фигурной скобки. Чтобы избежать эту ошибки, печатайте закрывающую фигурную скобку всякий раз, когда печатаете открывающую фигурную скобку как показано в следующем примере:
Если вы используете IDE такую как NetBeans и Eclipse, то IDE автоматически вставит закрывающую фигурную скобку каждой введённой вами открывающей фигурной скобки.
Частые ошибки 2: Пропуск точки с запятой
Каждая инструкция заканчивается ограничителем инструкции (;). Часто новые программисты забывают поместить ограничитель инструкции для последней инструкции в блоке как это показано в следующем примере:
Частые ошибки 3: Пропуск кавычки
Строки должны помещаться в кавычки. Часто начинающие программисты забывают поместить кавычку в конце строки как показано в следующем примере:
Если вы используете IDE, такую как NetBeans и Eclipse, то IDE автоматически вставит закрывающую кавычку каждый раз, когда вы ввели открывающую кавычку.
Частые ошибки 4: Неправильное написание имён
Java чувствительная к регистру. Неправильное написание имён – частая ошибка для новых программистов. Например, пишут слово main как Main, а вместо String пишут string. Пример:
Ошибки в программировании. Примеры ошибок в языке Паскаль
Ошибки в
программировании бывают двух типов:
синтаксические и логические. Синтаксические
ошибки это неправильное написание
ключевых слов и символов языка
программирования. Все виды синтаксических
ошибок могут быть найдены компьютером
в 99 % случаев.
Логические ошибки
связаны с неправильной программной
реализацией логики алгоритма. В 99 %
случаев компьютер будет выполнять
программу, но результат работы будет
неправильный.
Примеры синтаксических
ошибок в языке Паскаль и их исправление:
Редактор
установит курсор на следующий символ
после пропущенного знака. После нажатия
любой клавиши, сообщение об ошибке
исчезает, и редактор переходит в режим
вставки. Надо подвести курсор к нужному
месту, поставить точку с запятой — “;”
и продолжить работу.
2)
В описании переменных не записана
переменная, а в программе она присутствует.
После пуска программы, будет выдано
сообщение:
Курсор
будет установлен на эту переменную.
Надо исправить ошибку, т.е. записать
переменную в раздел описаний переменных
и продолжить работу.
3)
Не поставлена точка после оператора
end в конце программы. Сообщение компилятора
будет таким:
Ошибки, которые обнаруживает компилятор, называют синтаксическими ошибками или ошибками компиляции. Синтаксические ошибки являются результатом ошибок в конструкции кода, таких как неправильное написание ключевого слова, пропуск необходимого знака пунктуации или использование открывающей фигурной скобки без соответствующей закрывающей фигурной скобки. Эти ошибки обычно легко обнаружить, поскольку компилятор говорит вам, где они находятся и что стало их причиной. Пример программы с синтаксической ошибкой:
Попытка компиляции приведённого кода:
Будет сообщено о четырёх ошибках, но в действительности программа содержит две ошибки:
Поскольку одна ошибка часто будет приводить к показу множества ошибок компиляции в разных строках, хорошей практикой является исправление ошибок начиная с верхней строки и постепенно двигаясь вниз. Исправление ошибок, которые ранее возникли в программе, может также исправить дополнительные ошибки, которые произошли позже.
Совет: если вы не знаете, как исправить ошибку, внимательно сравните вашу программу, символ за символом с похожими примерами в тексте. На начальном этапе обучения вы, вероятно, будете проводить много времени исправляя ошибки синтаксиса. Скоро вы будете знакомы с синтаксисом Java и сможете быстро исправлять синтаксические ошибки.
Логические ошибки
Логические ошибки происходят, когда программа неправильно выполняет то, для чего она была создана. Ошибки этого рода возникают по многим различным причинам. Допустим, вы написали программу, которая конвертирует 35 градусов Цельсия в градусы Фаренгейта следующим образом:
Вы получите 67 градусов по Фаренгейту, что является неверным. Должно быть 95.0. В Java целочисленное деление показывает только часть – дробная часть отсекается, по этой причине в Java 9 / 5 это 1. Для получения правильного результата, нужно использовать 9.0 / 5, что даст результат 1.8.
Обычно ошибки синтаксиса легко обнаружить и легко исправить, поскольку компилятор даёт указания откуда пришла ошибка и что не так. Ошибки во время выполнения не трудны для поиска, поскольку причина и место для этих ошибок также показывается в консоли во время прерывания программы. Поиск логических ошибок, в свою очередь, очень сложный. В последующих главах вы обучитесь техникам трассировки программ и поиска логических ошибок.
Проверь себя
Для
программиста на языке Си память компьютера
представляется как набор ячеек, каждая
из которых называется переменной,
или константой,
в зависимости от того, меняется ее
значение в процессе работы или нет.
Каждая переменная имеет имя (идентификатор,
ID).
Константа может иметь или не иметь
имени.
Род
информации, которую способна хранить
ячейка, определяется ее типом.