Devcpp 1

1
Программирование на языке Си. © К. Поляков, 1995-2012
Глава I.
Введение в программирование
1. Простейшие программы......................................................................................... 3
Зачем нужно программирование? ........................................................................... 3
Два этапа создания программ................................................................................... 3
Простейшая программа на Си ................................................................................. 4
Вывод текста на экран ............................................................................................... 4
Как запустить программу? ....................................................................................... 5
Остановим мгновение ................................................................................................ 5
2. Переменные ............................................................................................................... 7
Типы данных и переменные ..................................................................................... 7
Вычисление суммы двух чисел (ввод и вывод)..................................................... 7
Арифметические выражения .................................................................................... 9
Форматы для вывода данных ................................................................................ 11
3. Выбор вариантов ................................................................................................... 14
Зачем нужны ветвления? ........................................................................................ 14
Условный оператор if — else............................................................................... 14
Сложные условия ...................................................................................................... 16
Переключатель switch (множественный выбор) ............................................. 17
4. Циклы ....................................................................................................................... 19
Зачем нужны циклы? ............................................................................................... 19
Цикл с известным числом шагов (for) ................................................................ 19
Цикл с условием (while) ........................................................................................ 20
Цикл с постусловием (do — while) .................................................................... 22
Досрочный выход из цикла..................................................................................... 23
Вычисление сумм последовательностей............................................................... 24
5. Методы отладки программ ................................................................................. 27
Отладочные средства Dev-C++ ............................................................................... 27
6. Работа в графическом режиме ........................................................................... 31
Простейшая графическая программа ................................................................... 31
Как начать рисовать? .............................................................................................. 31
Пример программы .................................................................................................. 34
7. Процедуры ............................................................................................................... 35
Пример задачи с процедурой .................................................................................. 35
8. Функции ................................................................................................................... 38
Отличие функций от процедур ............................................................................... 38
Логические функции ................................................................................................ 39
Функции, возвращающие два значения ............................................................... 40
9. Структура программ ............................................................................................ 42
Составные части программы ................................................................................. 42
Глобальные и локальные переменные ................................................................. 42
Оформление текста программы............................................................................. 43
10. Анимация............................................................................................................. 46
Что такое анимация?................................................................................................ 46
Движение объекта ..................................................................................................... 46
http://kpolyakov.spb.ru
2
I. Введение в программирование © К. Поляков, 1995-2009
Управление клавишами-стрелками ..................................................................... 48
11. Случайные и псевдослучайные числа .............................................................. 51
Что такое случайные числа? .................................................................................. 51
Распределение случайных чисел ........................................................................... 51
Функции для работы со случайными числами .................................................. 52
Случайные числа в заданном интервале ............................................................. 52
Снег на экране........................................................................................................... 53
http://kpolyakov.narod.ru
3
1. Простейшие программы
Зачем нужно программирование?

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

Программа на языке Си, так же как и на большинстве современных языков программиро-
вания, создается в два этапа
1) трансляция – перевод текста программы в машинные коды;
2) компоновка – сборка частей программы и подключение стандартных функций.
Исходный файл:
first.cpp
транслятор
Объектный файл: Стандартные

first.o функции
компоновщик
Исполняемый файл:
first.exe
Почему же не сделать все за один шаг? Для простейших программ это действительно было бы
проще, но для сложных проектов двухступенчатый процесс имеет явные преимущества:
• обычно сложная программа разбивается на несколько отдельных частей (модулей), которые

отлаживаются отдельно и зачастую разными людьми; поэтому в завершении остается лишь
собрать готовые модули в единый проект;
• при исправлении в одном модуле не надо снова транслировать (переводить в машинные ко-
ды) все остальные (это могут быть десятки тысяч строк);
• при компоновке во многих системах можно подключать модули, написанные на других
языках, например, на Ассемблере (в машинных кодах).
Трансляторы языка Си называются компиляторами: они переводят (транслируют) сразу
всю программу в машинный код, а не транслируют строчка за строчкой во время выполнения,
как это делают интерпретаторы. Это позволяет значительно ускорить выполнение программы
и не ставить интерпретатор на каждый компьютер, где программа будет выполняться.
4
Исходный файл программы на языке Си имеет расширение *.с или *.cpp (расширение
*.cpp говорит о том, что в программе могут быть использованы возможности языка Си++).
Это обычный текстовый файл, в который записывают текст программы в любом текстовом ре-
дакторе, например, в Блокноте.
Транслятор переводит исходный файл (вернее, записанную в нём программу) в машин-
ные коды и строит так называемый объектный файл с тем же именем и расширением *.o. Хо-
тя в нем уже записан машинный код, объектный файл еще нельзя запускать на компьютере,
потому что в нем не хватает стандартных функций (например, для ввода и вывода данных).
Компоновщик подключает стандартные функции, хранящиеся в библиотеках (они имеют
расширение *.a). В результате получается один файл с расширением *.exe, который и пред-
ставляет собой готовую программу.
Простейшая программа на Си
Такая программа состоит всего из 8 символов. Вот она:
main()
{
}
Основная программа всегда называется именем main (будьте внимательны – Си различает
большие и маленькие буквы, а все стандартные операторы Си записываются маленькими бук-
вами). Пустые скобки означают, что main не имеет аргументов. Фигурные скобки обозначают
начало и конец основной программы – поскольку внутри них ничего нет, наша программа ни-
чего не делает, она просто соответствует правилам языка Си, ее можно скомпилировать и полу-
чить exe-файл.
Вывод текста на экран

Составим теперь программу, которая делает что-нибудь полезное, например, выводит на
экран слово «Привет».
подключение функций стандартного
#include <stdio.h> ввода и вывода, описание которых
main() находится в файле stdio.h
{
printf("Привет");
} вызов функции
вывода на экран
Что новенького?
• Чтобы использовать стандартные функции, необходимо сказать транслятору, что есть
функция с таким именем и перечислить тип ее аргументов – тогда он сможет определить,
верно ли мы ее используем. Это значит, что надо включить в программу описание этой
функции. Описания стандартных функций Си находятся в так называемых заголовочных
файлах с расширением *.h (в каталоге C:\Dev-Cpp\include).
• Для подключения заголовочных файлов используется директива (команда) препроцессо-

ра1 #include, после которой в угловых скобках ставится имя файла. Внутри угловых
1
Препроцессор – это специальная программа, которая обрабатывает текст вашей программы раньше транслятора.
Все команды препроцессора начиняются знаком #.
5
скобок не должно быть пробелов. Для подключения еще каждого нового заголовочного
файла надо использовать новую команду #include.
• Для вывода информации на экран используется функция printf. В простейшем случае

она принимает единственный аргумент – строку в кавычках, которую надо вывести на эк-
ран.
• Каждый оператор языка Си заканчивается точкой с запятой.
Как запустить программу?

Чтобы проверить эту программу, надо сначала «напустить» на нее транслятор, который
переведет ее в машинные коды, а затем – компоновщик, который подключит стандартные
функции и создаст исполняемый файл. Раньше все это делали, вводя команды в командной
строке или с помощью так называемых пакетных файлов. На современном уровне все этапы
создания, трансляции, компоновки, отладки и проверки программы объединены и выполняют-
ся внутри специальной программы-оболочки, которую называют интегрированная среда раз-
работки (IDE – integrated development environment). В нее входят
• редактор текста
• транслятор
• компоновщик
• отладчик
В этой среде вам достаточно набрать текст программы и нажать на одну клавишу, чтобы она
выполнилась (если нет ошибок).
В оболочке Dev-C++ для запуска программы надо нажать клавишу F9. Если в программе
есть ошибки, вы увидите в нижней части экрана оболочки сообщения об этих ошибках (к сожа-
лению, на английском языке). Если щелкнуть по одной из этих строчек, в тексте программы
выделяется строка, в которой транслятору что-то не понравилось.
При поиске ошибок надо помнить, что
• часто ошибка сделана не в выделенной строке, а в предыдущей – проверяйте и ее тоже;
• часто одна ошибка вызывает еще несколько, и появляются так называемые наведенные
ошибки.
Остановим мгновение
Если запускать рассмотренную выше программу, то обнаружится, что программа сразу
заканчивает работу и возвращается обратно в оболочку, не дав нам посмотреть результат ее
работы на экране. Бороться с этим можно так – давайте скажем компьютеру, что в конце рабо-
ты надо дождаться нажатия любой клавиши.
#include <stdio.h> подключение заголовочного
#include <conio.h> файла conio.h
main()
{
printf("Привет"); // вывод на экран
getch(); /*ждать нажатия клавиши*/
}
• Задержка до нажатия любой клавиши выполняется функцией getch().
• Описание этой функции находится в заголовочном файле conio.h.
6
• Знаки // обозначают начало комментария — все правее них до конца строки не обраба-
тывается транслятором и служит нам для пояснения программы.
• Комментарий также можно ограничивать парами символов /* (начало комментария) и */
(конец комментария). В этом случае комментарий может быть многострочный, то есть со-
стоять из нескольких строк.
7
2. Переменные
Типы данных и переменные

Для обработки данных их необходимо хранить в памяти. При этом к этим данным надо
как-то обращаться. Обычно люди обращаются друг к другу по имени, такой же способ исполь-
зуется в программировании: каждой ячейке памяти (или группе ячеек) дается свое собственное
имя. Используя это имя можно прочитать информацию из ячейки и записать туда новую ин-
формацию.
Переменная - это ячейка в памяти компьютера, которая имеет имя и хранит некоторое зна-
чение. Значение переменной может меняться во время выполнения программы. При записи в
ячейку нового значения старое стирается.
С точки зрения компьютера все данные в памяти – это числа (более точно – наборы нулей и
единиц). Тем не менее, вы (и компьютер) знаете, что с целыми и дробными числами работают
по-разному. Поэтому в каждом языке программирования есть разные типы данных, для обра-
ботки которых используются разные методы. Например,
• целые переменные – тип int (от английского integer – целый), занимают 4 байта в памя-
ти;
• вещественные переменные, которые могут иметь дробную часть (тип float – от анг-
лийского floating point – плавающая точка) , занимают 4 байта в памяти
• символы (тип char – от английского character – символ), занимают 1 байт в памяти
Любую переменную, которые вы будете использовать в программе, необходимо объявлять –
сказать компьютеру, чтобы он выделил для неё ячейку памяти нужного размера и присвоил ей
имя. Переменные обычно объявляются в начале программы. Для объявления надо написать на-
звание типа переменных (int, float или char), а затем через запятую имена всех объявляе-
мых переменных. При желании можно сразу записать в новую ячейку нужное значение, как
показано в примерах ниже. Если переменной не присваивается никакого значения, то в ней на-
ходится «мусор», то есть то, что было там раньше.
Примеры.
int a; // выделить память под целую переменную a

float b, c; // две вещественных переменных b и c
int Tu104, Il86=23, Yak42; // три целых переменных,
// в Il86 сразу записывается число 23
float x=4.56, y, z; // три вещественных переменных,
// в x сразу записывается число 4.56
char c, c2='A', m; // три символьных переменных, в c2
// сразу записывается символ 'A'
Вычисление суммы двух чисел (ввод и вывод)

Задача. Ввести с клавиатуры два целых числа и вывести на экран их сумму.
Сразу запишем решение задачи на языке Си.
8
#include <stdio.h>
#include <conio.h>
main()
{
int a, b, c; // объявление переменных
printf ( "Введите два целых числа \n" ); // подсказка для ввода
scanf ( "%d%d", &a, &b ); // ввод данных
c = a + b; // вычисления (оператор присваивания)
printf ( "Результат: %d + %d = %d \n",
a, b, c ); // вывод результата
getch();
}
• Программа чаще всего содержит 4 части:
o объявление переменных;
o ввод исходных данных;
o обработка данных (вычисления);
o вывод результата.
• Перед вводом данных необходимо вывести на экран подсказку (иначе компьютер будет
ждать ввода данных, а пользователь не будет знать, что от него хочет машина).
• Символы \n в функции printf обозначают переход в начало новой строки.
• Для ввода данных используют функцию scanf.
формат ввода адреса переменных
scanf ( "%d%d", &a, &b );

o Формат ввода – это строка в кавычках, в которой перечислены один или несколько
форматов ввода данных:
%d ввод целого числа (переменная типа int)
%f ввод вещественного числа (переменная типа float)
%с ввод одного символа (переменная типа char)
o После формата ввода через запятую перечисляются адреса ячеек памяти, в которые на-
до записать введенные значения. Почувствуйте разницу:
a значение переменной a
&a адрес переменной a
o Количество форматов в строке должно быть равно количеству адресов переменных в
списке. Кроме того, тип переменных должен совпадать с указанным: например, если a
и b – целые переменные, то следующие вызовы функций ошибочны
scanf ( "%d%d", &a ); куда записывать второе введенное число?
scanf ( "%d%d", &a, &b, &c ); не задан формат для переменной c
scanf ( "%f%f", &a, &b ); нельзя вводить целые переменные по ве-
щественному формату
• Для вычислений используют оператор присваивания, в котором

o справа от знака равенства стоит арифметическое выражение, которое надо вычислить
9
o слева от знака равенства ставится имя переменной, в которую надо записать результат
c = a + b; // сумму a и b записать в c
• Для вывода чисел и значений переменных на экран используют функцию printf
эти символы вывести здесь вывести целые
без изменений числа данные для вывода
printf ( "Результат: %d + %d = %d \n", a, b, c );

содержание скобок при вызове функции printf очень похоже на функцию scanf
o Сначала идет символьная строка — формат вывода — в которой можно использовать
специальные символы
%d вывод целого числа
%f вывод вещественного числа
%с вывод одного символа
%s вывод символьной строки
\n переход в начало новой строки
все остальные символы (кроме некоторых других специальных команд) просто выво-
дятся на экран.
o Одной строки формата недостаточно: в ней сказано, в какое место выводить данные, но
не сказано, откуда их взять. Поэтому через запятую после формата вывода надо поста-
вить список чисел или переменных, значения которых надо вывести, при этом можно
сразу проводить вычисления.
printf ( "Результат: %d + %d = %d \n", a, 5, a+5 );
o Так же, как и для функции scanf, надо следить за совпадением типов и количества пе-
ременных и форматов вывода.
Арифметические выражения
Из чего состоят арифметические выражения?
Арифметические выражения, стоящие в правой части оператора присваивания, могут содер-
жать
• целые и вещественные числа (в вещественных числах целая и дробная часть разделяются
точкой, а не запятой, как это принято в математике)
• знаки арифметических действий
+ — сложение, вычитание
* / умножение, деление
% остаток от деления
• вызовы стандартных функций
abs(i) модуль целого числа i
fabs(x) модуль вещественного числа x
sqrt(x) квадратный корень из вещественного числа x
pow(x,y) вычисляет x в степени y
• круглые скобки для изменения порядка действий
10
Особенности арифметических операций
При использовании деления надо помнить, что
При делении целого числа на целое остаток от деления отбрасывается, таким

образом, 7/4 будет равно 1. Если же надо получить вещественное число и не от-
брасывать остаток, делимое или делитель надо преобразовать к вещественной
форме. Например:
int i, n;
float x;
i = 7;
x = i / 4; // x=1, делится целое на целое
x = i / 4.; // x=1.75, делится целое на дробное
x =(float) i / 4; // x=1.75, делится дробное на целое
n = 7. / 4.; // n=1, результат записывается в
// целую переменную
Наибольшие сложности из всех действий вызывает взятие остатка. Если надо вычислить оста-
ток от деления переменной a на переменную b и результат записать в переменную ostatok,
то оператор присваивания выглядит так:
ostatok = a % b;
Приоритет арифметических операций

В языках программирования арифметические выражения записываются в одну строчку,
поэтому необходимо знать приоритет (старшинство) операций, то есть последовательность их
выполнения. Сначала выполняются
• операции в скобках, затем…
• вызовы функций, затем…
• умножение, деление и остаток от деления, слева направо, затем…
• сложение и вычитание, слева направо.
Например:
2 1 5 4 3 8 6 7
x = ( a + 5 * b ) * fabs ( c + d ) — ( 3 * b — c );
Для изменения порядка выполнения операций используются круглые скобки. Выражение
4x + 5 5x
y= −
( 2x − 15z )(3z − 3) x + z + 3
в компьютерном виде запишется в виде
y = (4*x + 5) / ((2*x — 15*z)*(3*z — 3)) — 5 * x /
(x + z + 3);
Странные операторы присваивания

В программировании часто используются несколько странные операторы присваивания,
например:
i = i + 1;
Если считать это уравнением, то оно бессмысленно с точки зрения математики. Однако с точки
зрения информатики этот оператор служит для увеличения значения переменной i на единицу.
11
Буквально это означает: взять старое значение переменной i, прибавить к нему единицу и за-
писать результат в ту же переменную i.
Инкремент и декремент
В языке Си определены специальные операторы быстрого увеличения на единицу (ин-
кремента)
i ++; // или...
++ i;
что равносильно оператору присваивания
i = i + 1;
и быстрого уменьшения на единицу (декремента)
i— —; // или...
— — i;
что равносильно оператору присваивания
i = i — 1;
Между первой и второй формами этих операторов есть некоторая разница, но только тогда, ко-
гда они входят в состав более сложных операторов или условий.
Сокращенная запись арифметических выражений

Если мы хотим изменить значение какой-то переменной (взять ее старое значение, что-то
с ним сделать и записать результат в эту же переменную), то удобно использовать сокращен-
ную запись арифметических выражений:
Сокращенная запись Полная запись
x += a; x = x + a;
x -= a; x = x - a;
x *= a; x = x * a;
x /= a; x = x / a;
x %= a; x = x % a;
Форматы для вывода данных

Целые числа
Первым параметром при вызове функций scanf и printf должна стоять символьная
строка, определяющая формат ввода или вывода данных. Для функции scanf, которая выпол-
няет ввод данных, достаточно просто указать один из форматов %d, %f или %c для ввода це-
лого числа, вещественного числа или символа, соответственно. В то же время форматная строка
в функции printf позволяет управлять выводом на экран, а именно, задать размер поля, кото-
рое отводится для данного числа.
Ниже показаны примеры форматирования при выводе целого числа 1234. Чтобы увидеть
поле, которое отводится для числа, оно ограничено слева и справа скобками.
Пример вывода Результат Комментарий
printf("[%d]", 1234); [1234] Минимально возможное поле.
12
printf("[%6d]", 1234); [ 1234] 6 позиций, выравнивание вправо.
printf("[%-6d]", 1234); [1234 ] 6 позиций, выравнивание влево.
Число не помещается в заданные 2
printf("[%2d]", 1234); [1234] позиции, поэтому область вывода
расширяется.
Для вывода символов используются такие же приемы форматирования, но формат %d заменяет-
ся на %c.
Вещественные числа
Для вывода (и для ввода) вещественных чисел могут использоваться три формата: %f,
%e и %g. В таблице показаны примеры использования формата %f.
printf("[%f]", 123.45); [123.450000] Минимально возможное поле,

6 знаков в дробной части.
Всего 9 позиций, из них 3 – для
printf("[%9.3f]", 123.45); [ 123.450] дробной части, выравнивание
вправо.
Всего 9 позиций, из них 3 – для
printf("[%-9.3f]", 123.45); [123.450 ] дробной части, выравнивание
влево.
Число не помещается в заданные
printf("[%6.4f]", 123.45); [123.4500] 6 позиций (4 цифры в дробной
части), поэтому область вывода
Формат %e применяется в научных расчетах для вывода очень больших или очень ма-
леньких чисел, например, размера атома или расстояния до Солнца. С представлением числа в
так называемом стандартном виде (с выделенной мантиссой и порядком). Например, число
123.45 может быть записано в стандартном виде как 123.45 = 1.2345 × 10 2 . Здесь 1.2345 –
мантисса (она всегда находится в интервале от 1 до 10), а 2 – порядок (мантисса умножается на
10 в этой степени). При выводе по формату %e также можно задать число позиций, которые
отводятся для вывода числа, и число цифр в дробной части мантиссы. Порядок всегда указыва-
ется в виде двух цифр, перед которыми стоит буква e и знак порядка (плюс или минус).

Минимально возможное по-
printf("[%e]", 123.45); [1.234500e+02] ле, 6 знаков в дробной части
мантиссы.
Всего 12 позиций, из них 3 –
printf("[%12.3e]", 123.45); [ 1.234e+02] для дробной части мантис-
сы, выравнивание вправо.
Всего 12 позиций, из них 3 –
printf("[%-12.3e]", 123.45); [1.234e+02 ] для дробной части мантис-
сы, выравнивание влево.
13
Число не помещается в за-
данные 6 позиций (2 цифры
printf("[%6.2e]", 123.45); [1.23e+02] в дробной части мантиссы),
поэтому область вывода
Формат %g применяется для того, чтобы удалить лишние нули в конце дробной части
числа и автоматически выбрать формат (в стандартном виде или с фиксированной точкой). Для
очень больших или очень маленьких чисел выбирается формат с плавающей точкой (в стан-
дартном виде). В этом формате можно задать общее число позиций на число и количество зна-
чащих цифр.
printf("[%g]", 12345); [12345]
Минимально возможное
printf("[%g]", 123.45); [123.45] поле, не более 6 значащих
printf("[%g]", 0.000012345); [1.2345e-05] цифр.
Всего 10 позиций, из них 3

printf("[%10.3g]", 12345); [ 1.23e+04] значащие цифры, выравни-
вание вправо. Чтобы сде-
printf("[%10.3g]", 123.45); [ 123]
лать выравнивание влево,
printf("[%10.3g]",0.000012345); [ 1.23e-05] используют формат
"%-10.3g".
14
3. Выбор вариантов
Зачем нужны ветвления?
В простейших программах все команды выполняются одна за другой последовательно.
Так реализуются линейные алгоритмы. Однако часто надо выбрать тот или иной вариант дейст-
вий в зависимости от некоторых условий: если условие верно, поступать одним способом, а
если неверно — другим. Для этого используют разветвляющиеся алгоритмы, которые в язы-
ках программирования представлены в виде условных операторов. В языке Си существует два
вида условных операторов:
• оператор if — else для выбора из двух вариантов
• оператор множественного выбора switch для выбора из нескольких вариантов
Условный оператор if — else

Задача. Ввести с клавиатуры два вещественных числа и определить наибольшее из них.
По условию задачи нам надо вывести один из двух вариантов ответа: если первое число
больше второго, то вывести на экран его, если нет — то второе число. Ниже показаны два вари-
анта решения этой задачи: в первом результат сразу выводится на экран, а во втором наиболь-
шее из двух чисел сначала записывается в третью переменную Max.
#include <stdio.h> #include <stdio.h>
#include <conio.h> #include <conio.h>
main() main()
{ {
float A, B; float A, B, Max;
printf ("Введите A и B :"); printf("Введите A и B : ");
scanf ( "%f%f", &A, &B ); scanf ( "%f%f", &A, &B );
if ( A > B ) if ( A > B ) // заголовок
{ {
printf ( "Наибольшее %f", Max = A; // блок «если»
A ); }
} else
else {
{ Max = B; // блок «иначе»
printf ( "Наибольшее %f", }
B ); printf ( "Наибольшее %f",
} Max );
getch(); getch();
} }
15
• Условный оператор имеет следующий вид:
if ( условие ) // заголовок с условием
{
... // блок «если» — операторы, которые выполняются,
// если условие в заголовке истинно
}
else
{
... // блок «иначе» — операторы, которые выполняются,
// если условие в скобках ложно
}
• Эта запись представляет собой единый оператор, поэтому между скобкой, завершающей
блок «если» и словом else не могут находиться никакие операторы.
• После слова else никогда НЕ ставится условие — блок «иначе» выполняется тогда, ко-
гда основное условие, указанное в скобках после if, ложно.
• Если в блоке «если» или в блоке «иначе» только один оператор, то фигурные скобки мож-
но не ставить.
• В условии можно использовать знаки логических отношений
> < больше, меньше
>= <= больше или равно, меньше или равно
== равно
!= не равно
• В языке Си любое число, не равное нулю, обозначает истинное условие, а ноль — ложное
условие.
• Если в блоке «иначе» не надо ничего делать (например: «если в продаже есть мороженое,
купи мороженое», а если нет ...), то весь блок «иначе» можно опустить и использовать со-
кращенную форму условного оператора:
if ( условие )
{
... // что делать, если условие истинно
}
Например, решение предыдущей задачи могло бы выглядеть так:
#include <stdio.h>
#include <conio.h>
main()
{
float A, B, Max;
printf("Введите A и B : ");
scanf ( "%f%f", &A, &B );
Max = A;
if ( B > A )
Max = B;
printf ( "Наибольшее %f", Max );
getch();
}
16
• В блоки «если» и «иначе» могут входить любые другие операторы, в том числе и другие
вложенные условные операторы; при этом оператор else относится к ближайшему пре-
дыдущему if:
if ( A > 10 )
if ( A > 100 )
printf ( "У вас очень много денег." );
else
printf ( "У вас достаточно денег." );
else
printf ( "У вас маловато денег." );
• Чтобы легче разобраться в программе, все блоки «если» и «иначе» (вместе с ограничи-
вающими их скобками) сдвигаются вправо на 2-3 символа (запись «лесенкой»).
Сложные условия
Простейшие условия состоят из одного отношения (больше, меньше и т.д.). Иногда надо
написать условие, в котором объединяются два или более простейших отношений. Например,
фирма отбирает сотрудников в возрасте от 25 до 40 лет (вклчительно). Тогда простейшая про-
грамма могла бы выглядеть так:
#include <stdio.h>
#include <conio.h>
main()
{
int age;
printf ( "\nВведите ваш возраст: " );
scanf ( "%d", &age );
if ( 25 <= age && age <= 40 ) // сложное условие
printf ( "Вы нам подходите." );
else
printf ( "Извините, Вы нам не подходите." );
getch();
}
• Сложное условие состоит из двух или нескольких простых отношений, которые объеди-
няются с помощью знаков логических операций:
o операция И — требуется одновременное выполнение двух условий
условие_1 && условие_2
Эту операцию можно описать следующей таблицей (она называется таблицей истин-
ности)
условие_1 условие_2 условие_1 && условие_2
ложно (0) ложно (0) ложно(0)
ложно (0) истинно (1) ложно(0)
истинно (1) ложно (0) ложно(0)
истинно (1) истинно (1) истинно (1)
17
o операция ИЛИ — требуется выполнение хотя бы одного из двух условий (или обоих
сразу)
условие_1 || условие_2
Таблица истинности запишется в виде

условие_1 условие_2 условие_1 || условие_2
ложно (0) ложно (0) ложно(0)
ложно (0) истинно (1) истинно (1)
истинно (1) ложно (0) истинно (1)
истинно (1) истинно (1) истинно (1)
o в сложных условиях иногда используется операция НЕ — отрицание условия (или об-
ратное условие)
! условие
Например, следующие два условия равносильны
A > B ! ( A <= B )
• Порядок выполнения (приоритет) логических операций и отношений:

o операции в скобках, затем
o операция НЕ, затем
o логические отношения >, <, >=, <=, ==, !=, затем
o операция И, затем
o операций ИЛИ
• Для изменения порядка действий используются круглые скобки.
Переключатель switch (множественный выбор)

Если надо выбрать один из нескольких вариантов в зависимости от значения некоторой
целой или символьной переменной, можно использовать несколько вложенных операторов if,
но значительно удобнее использовать специальный оператор switch.
Задача. Составить программу, которая вводит с клавиатуры русскую букву и выводит на эк-
ран название животного на эту букву.
#include <stdio.h>
#include <conio.h>
main()
{
char c;
printf("\nВведите первую букву:");
scanf("%c", &c); // ввести букву
switch ( c ) // заголовок оператора выбора
{
case 'а': printf("\nАнтилопа"); break;
case 'б': printf("\nБарсук"); break;
case 'в': printf("\nВолк"); break;
default: printf("\nНе знаю я таких!"); // по умолчанию
}
getch();
}
18
• Оператор множественного выбора switch состоит из заголовка и тела оператора, заклю-
ченного в фигурные скобки.
• В заголовке после ключевого слова switch в круглых скобках записано имя переменной
(целой или символьной). В зависимости от значения этой переменной делается выбор ме-
жду несколькими вариантами.
• Каждому варианту соответствует метка case, после которой стоит одно из возможных
значений этой переменной и двоеточие; если значение переменной совпадает с одной из
меток, то программа переходит на эту метку и выполняет все последующие операторы.
• Оператор break служит для выхода из тела оператора switch. Если убрать все опера-
торы break, то, например, при нажатии на букву a будет напечатано
Антилопа
Барсук
Волк
Не знаю таких!
• Если значение переменной не совпадает ни с одной из меток, программа переходит на
метку default (по умолчанию, то есть если ничего другого не указано).
• Можно ставить две метки на один оператор. Например, чтобы программа реагировала как
на большие, так и на маленькие буквы, надо в теле оператора switch написать так:
case 'а':
case 'А':
printf("\nАнтилопа"); break;
case 'б':
case 'Б':
printf("\nБарсук"); break;
и так далее.
19
4. Циклы
Зачем нужны циклы?

Теперь посмотрим, как вывести на экран это самое приветствие 10 раз. Конечно, можно напи-
сать 10 раз оператор printf, но если надо вывести строку 200 раз, то программа значительно
увеличится. Поэтому надо использовать циклы.
Цикл - это последовательность команд, которая выполняется несколько раз.
В языке Си существует несколько видов циклов.
Цикл с известным числом шагов (for)

Часто мы заранее знаем заранее (или можем рассчитать), сколько раз нам надо выполнить
какую-то операцию. В некоторых языках программирования для этого используется цикл
repeat – «повтори заданное количество раз». Подумаем, как выполнять такой цикл. В памяти
выделяется ячейка и в нее записывается число повторений. Когда программа выполняет тело
цикла один раз, содержимое этой ячейки (счетчик) уменьшается на единицу. Выполнение цик-
ла заканчивается, когда в этой ячейке будет ноль.
В языке Си цикла repeat нет, а есть цикл for. Он не скрывает ячейку-счетчик, а требует
явно объявить ее (выделить под нее память), и даже позволяет использовать ее значение в теле
цикла. Ниже показан пример программы, которая печатает приветствие 10 раз.
#include <stdio.h>
#include <conio.h>
main()
{
int i; // объявление переменной цикла
for ( i = 1; i <= 10; i ++ ) // заголовок цикла
{ // начало цикла (открывающая скобка)
printf("Привет"); // тело цикла
} // конец цикла (закрывающая скобка)
getch();
}
• Цикл for используется тогда, когда количество повторений цикла заранее известно или
может быть вычислено.
• Цикл for состоит из заголовка и тела цикла.
• В заголовке после слова for в круглых скобках записываются через точку с запятой три
выражения:
o начальные значения: операторы присваивания, которые выполняются один раз перед
выполнением цикла;
o условие, при котором выполняется следующий шаг цикла; если условие неверно,
работа цикла заканчивается; если оно неверно в самом начале, цикл не выполняется ни
одного раза (говорят, что это цикл с предусловием, то есть условие проверяется перед
выполнением цикла);
20
o действия в конце каждого шага цикла (в большинстве случаев это операторы при-
сваивания).
• В каждой части заголовка может быть несколько операторов, разделенных запятыми.
Примеры заголовков:
for ( i = 0; i < 10; i ++ ) { ... }
for ( i = 0, x = 1.; i < 10; i += 2, x *= 0.1 ){ ... }
• Тело цикла заключается в фигурные скобки; если в теле цикла стоит всего один оператор,
скобки можно не ставить.
• В тело цикла могут входить любые другие операторы, в том числе и другие циклы (такой
прием называется «вложенные циклы»).
• Для того, чтобы легче разобраться в программе, все тело цикла и ограничивающие его
скобки сдвигаются вправо на 2-3 символа (запись «лесенкой»).
Чему равен квадрат числа?

Напишем программу, которая вводит с клавиатуры натуральное число N и выводит на эк-
ран квадраты всех целых чисел от 1 до N таком виде
Квадрат числа 1 равен 1
Квадрат числа 2 равен 4
...
#include <stdio.h>
#include <conio.h>
main()
{
int i, N; // i – переменная цикла
printf ( "Введите число N: " ); // подсказка для ввода
scanf ( "%d", &N ); // ввод N с клавиатуры
for ( i = 1; i <= N; i ++) // цикл: для всех i от 1 до N
{
printf ( "Квадрат числа %d равен %d\n", i, i*i);
}
getch();
}
Мы объявили две переменные: N — максимальное число, i — вспомогательная переменная,
которая в цикле принимает последовательно все значения от 1 до N. Для ввода значения N мы
напечатали на экране подсказку и использовали функцию scanf с форматом %d (ввод целого
числа).
При входе в цикл выполняется оператор i = 1, и затем переменная i с каждым шагом
увеличивается на единицу (i ++). Цикл выполняется пока истинно условие i <= N. В теле цик-
ла единственный оператор вывода печатает на экране само число и его квадрат по заданному
формату. Для возведения в квадрат или другую невысокую степень лучше использовать умно-
жение.
Цикл с условием (while)

Очень часто заранее невозможно сказать, сколько раз надо выполнить какую-то опера-
цию, но можно определить условие, при котором она должна заканчиваться. Такое задание на
русском языке может выглядеть так: делай эту работу до тех пор, пока она не будет закончена
21
(пили бревно, пока оно не будет распилено; иди вперед, пока не дойдешь до двери). Слово «по-
ка» на английском языке записывается как while, и так же называется еще один вид цикла.
Задача. Ввести целое число и определить, сколько в нем цифр.
Для решения этой задачи обычно применяется такой алгоритм. Число делится на 10 и от-
брасывается остаток, и так до тех пор, пока результат деления не равен нулю. С помощью спе-
циальной переменной (она называется счетчиком) считаем, сколько раз выполнялось деление –
столько цифр и было в числе. Понятно, что нельзя заранее определить, сколько раз надо разде-
лить число, поэтому надо использовать цикл с условием.
#include <stdio.h>
#include <conio.h>
main()
{
int N; // число, с которым работаем
int count=0; // переменная-счетчик
printf ( "\nВведите число N: " ); // подсказка
scanf ( "%d", &N ); // ввод N с клавиатуры
while ( N > 0 ) // заголовок цикла «пока N > 0»
{ // начало цикла (открывающая скобка)
N /= 10; // отсекаем последнюю цифру
тело цикла
count ++; // увеличиваем счетчик цифр
} // конец цикла (закрывающая скобка)
printf ( "В этом числе %d цифр\n", count );
getch();
}
• Цикл while используется тогда, когда количество повторений цикла заранее неизвестно
и не может быть вычислено.
• Цикл while состоит из заголовка и тела цикла.
• В заголовке после слова while в круглых скобках записывается условие, при котором
цикл продолжает выполняться. Когда это условие нарушается (становится ложно), цикл
заканчивается.
• В условии можно использовать знаки логических отношений и операций
> < больше, меньше
>= <= больше или равно, меньше или равно
== равно
!= не равно
• Если условие неверно в самом начале, то цикл не выполняется ни разу (это цикл с преду-
словием).
• Если условие никогда не становится ложным (неверным), то цикл никогда не заканчива-
ется; в таком случае говорят, что программа «зациклилась» — это серьезная логическая
ошибка.
• В языке Си любое число, не равное нулю, обозначает истинное условие, а ноль — ложное
условие:
while ( 1 ){ ... } // бесконечный цикл

22
while ( 0 ){ ... } // цикл не выполнится ни разу
Цикл с постусловием (do — while)

Существуют также случаи, когда надо выполнить цикл хотя бы один раз, затем на каждом
шагу делать проверку некоторого условия и закончить цикл, когда это условие станет ложным.
Для этого используется цикл с постусловием (то есть условие проверяется не в начале, а в
конце цикла). Не рекомендуется применять его слишком часто, поскольку он напоминает такую
ситуацию: прыгнул в бассейн, и только потом посмотрел, есть ли в нем вода. Рассмотрим слу-
чай, когда его использование оправдано.
Задача. Ввести натуральное число и найти сумму его цифр. Организовать ввод числа так, что-
бы нельзя было ввести отрицательное число или ноль.
Любая программа должна обеспечивать защиту от неверного ввода данных (иногда такую
защиту называют «защитой от дурака» — fool proof). Поскольку пользователь может вводить
данные неверно сколько угодно раз, то надо использовать цикл с условием. С другой стороны,
один раз обязательно надо ввести число, поэтому нужен цикл с постусловием.
В отличие от предыдущей программы, теперь надо при каждом делении определять оста-
ток (последняя цифра числа равна остатку от деления его на 10) и суммировать все остатки в
специальной переменной.
#include <stdio.h>
#include <conio.h>
main()
{
int N, sum; // sum - сумма цифр числа
sum = 0; // сначала сумму обнуляем
do { // начало цикла
printf ( "\nВведите натуральное число:" );
scanf ( "%d", &N );
}
while ( N <= 0 ); // условие цикла «пока N <= 0»
while ( N > 0 ) {
sum += N % 10;
N /= 10;
}
printf ( "Сумма цифр этого числа равна %d\n", sum );
getch();
}
• Цикл do—while используется тогда, когда количество повторений цикла заранее неиз-
вестно и не может быть вычислено.
23
• Цикл состоит из заголовка do, тела цикла и завершающего условия.
• Условие записывается в круглых скобках после слова while, цикл продолжает выпол-
няться, пока условие верно; когда условие становится неверно, цикл заканчивается.
• Условие проверяется только в конце очередного шага цикла (это цикл с постусловием),
таким образом, цикл всегда выполняется хотя бы один раз.
• Если условие никогда не становится ложным (неверным), то цикл никогда не заканчива-
ется; в таком случае говорят, что программа «зациклилась» — это серьезная логическая
ошибка.
Досрочный выход из цикла

Иногда надо выйти из цикла и перейти к следующему оператору, не дожидаясь оконча-
ния очередного шага цикла. Для этого используют специальный оператор break. Можно также
сказать компьютеру, что надо завершить текущий шаг цикла и сразу перейти к новому шагу (не
выходя из цикла) — для этого применяют оператор continue.
Задача. Написать программу, которая вычисляет частное и остаток от деления двух введенных
целых чисел. Программа должна работать в цикле, то есть запрашивать значения делимого и
делителя, выводить результат, снова запрашивать данные и т.д. Если оба числа равны нулю,
надо выйти из цикла и завершить работу программы. Предусмотреть сообщение об ошибке в
том случае, если второе число равно нулю, а первое — нет.
Особенность этой задачи состоит в том, что при входе в цикл мы не можем определить,
надо ли будет выполнить до конца очередной шаг. Необходимая информация поступает лишь
при вводе данных с клавиатуры. Поэтому здесь используется бесконечный цикл
while(1){...} (напомним, что в языке Си единица считается истинным условием). Выйти
из такого цикла можно только с помощью специального оператора break.
В то же время, если второе число равно нулю, то оставшуюся часть цикла не надо выпол-
нять. Для этого служит оператор continue.
#include <stdio.h>
#include <conio.h>
main()
{
int A, B;
while ( 1 ) // бесконечный цикл, выход только по break!
{
printf ( "\nВведите делимое и делитель:" );
scanf ( "%d%d", &A, &B );
if ( A == 0 && B == 0 ) break; // выход из цикла
if ( B == 0 ) {
printf ( "Деление на ноль" );
continue; // досрочный переход к новому шагу цикла
}
24
printf ( "Частное %d, остаток %d", A/B, A%B );
}
getch();
}
• Если только внутри цикла можно определить, надо ли делать вычисления в теле цикла и надо
ли продолжать цикл (например, при вводе исходных данных), часто используют бесконеч-
ный цикл, внутри которого стоит оператор выхода break:
while ( 1 ) {
...
if ( надо выйти ) break;
...
}
• С помощью оператора break можно досрочно выходить из любых циклов: for, while,
do—while.
• Чтобы досрочно завершить текущий шаг цикла и сразу перейти к следующему шагу, исполь-
зуют оператор continue.
Вычисление сумм последовательностей

Суммы с заданным числом элементов
Задача. Найти сумму первых 20 элементов последовательности
1 2 3 4
S = − + − +L
2 4 8 16
Чтобы решить эту задачу, надо определить закономерность в изменении элементов. В данном
случае можно заметить, что
• каждый элемент представляет собой дробь;
• числитель дроби при переходе к следующему элементу возрастает на единицу;
• знаменатель дроби с каждым шагом увеличивается в 2 раза;
• знаки перед дробями чередуются (плюс, минус и т.д.).
Любой элемент последовательности можно представить в виде
zc
ai =
,
d
где изменение переменных z, c и d описываются следующей таблицей (для первых пяти эле-
ментов)
i 1 2 3 4 5
z 1 -1 1 -1 1
c 1 2 3 4 5
d 2 4 8 16 32
У переменной z меняется знак (эту операцию можно записать в виде z = -z), значение пере-
менной c увеличивается на единицу (c ++), а переменная d умножается на 2 (d = d*2). Алго-
ритм решения задачи можно записать в виде следующих шагов:
• записать в переменную S значение 0; в этой ячейке будет накапливаться сумма;
25
• записать в переменные z, c и d начальные значения (для первого элемента):
z = 1, c = 1, d = 2.
• сделать 20 раз:
o добавить к сумме значение очередного элемента;
o изменить значения переменных z, c и d для следующего элемента.
#include <stdio.h>
main()
{
float S, z, c, d;
int i;
S = 0; z = 1; c = 1; d = 2; // начальные значения
for ( i = 1; i <= 20; i ++ )
{
S = S + z*c/d; // добавить элемент к сумме
z = - z; // изменить переменные z, c, d
c ++;
d = d * 2;
}
printf("Сумма S = %f", S);
}
Суммы с ограничивающим условием

Рассмотрим более сложную задачу, когда количество элементов заранее неизвестно.
Задача. Найти сумму всех элементов последовательности
1 2 3 4
S = − + − + L,
2 4 8 16
которые по модулю не меньше, чем 0,001.
Эта задача имеет решение только тогда, когда элементы последовательности убывают по моду-
лю и стремятся к нулю. Поскольку мы не знаем, сколько элементов войдет в сумму, надо ис-
пользовать цикл while (или do-while). Один из вариантов решения показан ниже.
#include <stdio.h>
main()
{
float S, z, c, d, a;
S = 0; z = 1; c = 1; d = 2; // начальные значения
a = 0.5; // первый элемент последовательности
while ( a >= 0.001 )
{
S = S + z*a; // добавить элемент к сумме
z = - z; // изменить переменные z, c, d
c ++;
d = d * 2;
a = c / d; // модуль следующего элемента
}
printf("Сумма S = %f", S);
}
26
Цикл закончится тогда, когда переменная a (она обозначает модуль очередного элемента по-
следовательности) станет меньше 0,001. Чтобы программа вошла в цикл на первом шаге, в эту
переменную надо записать любое значение, большее, чем 0,001.
Очевидно, что если переменная a не будет уменьшаться, то условие в заголовке цикла
всегда будет истинно и программа «зациклится».
27
5. Методы отладки программ
Отладочные средства Dev-C++

Что такое отладка?
Слово «отладка» означает «поиск и исправление ошибок в программе». Соответствующий
английский термин debugging (дословно «удаление жучков») по преданию связан с тем, что в
контакты компьютера Mark II в 1940 году попал жучок (моль), из-за которого в вычислитель-
ной машине произошел сбой.
Существует три типа ошибок в программах:
• синтаксические – ошибки в написании операторов (например, вместо printf часто не-
правильно пишут просто print); эти ошибки легко исправить, потому что их обнару-
живает транслятор и чаще всего говорит, в какой именно строчке ошибка;
• ошибки времени выполнения – во время работы случилась «аварийная» ситуация, напри-
мер, деление не ноль;
• логические – ошибки в алгоритме (программа работает, но выполняет не то, что нужно);
эти ошибки сложнее всего обнаружить, потому что иногда они проявляются совсем не в
том месте, где находится неверная команда.
Итак, самое трудное во время отладки – это найти ошибку, то есть определить ошибочный опе-
ратор. К сожалению, эту задачу никак не удается автоматизировать, ее может решить только
человек. Для облегчения этой работы придумали хитрые приемы и написали специальные про-
граммы – отладчики.
Трассировка
Трассировка – это вывод сигнальных сообщений в определенных точках программы во
время ее работы. Что же это дает?
Во-первых, получив такое сообщение на экран, мы знаем, что программа вышла в эту точ-
ку (не завершила работу аварийно раньше и не зациклилась). Во-вторых, в этих сообщениях
можно выводить не только текст, но и значения переменных – это позволяет проверять, пра-
вильно ли считает программа. Если, например, во 2-ой контрольной точке все значения пере-
менных были верные, а в 3-ой уже нет, то ошибку нужно искать между этими точками.
В этой программе в трех точках (1, 2 и 3) стоят операторы трассировки:
main()
{
int i, X;
printf("Введите целое число:\n");
scanf("%d", &X);
printf("Введено X=%d\n", X); // точка 1
for(i=1; i<10; i++)
{
printf("В цикле: i=%d, X=%d\n", i, X); // точка 2
...
}
printf("После цикла: X=%d\n", X); // точка 3
...
}
В точке 1 мы увидим на экране число, которое находится в переменной X после ввода зна-
чения с клавиатуры – так можно проверить правильность ввода.
28
В точке 2 мы выводим на экран значения переменных на каждом шаге цикла. Это позво-
ляет сверить их с ручным расчетом и выяснить, верно ли выполняются вычисления в цикле.
В точке 3 значение переменной X после завершения цикла выводится на экран.
Заметим, что трассировку можно применять практически всегда, для этого не нужна про-
грамма-отладчик.
Отключение части кода

Нередко бывает так: в результате усовершенствований работавшая программа перестает
работать. В такой ситуации для поиска ошибки нужно как-то убрать из программы весь новый
код и добавлять его «маленькими порциями», чтобы определить, какие именно добавленные
операторы портят все дело. Удалять код из программы совсем не хочется, но можно его отклю-
чить, сделав комментарием.
Чтобы отключить одну строчку программы, перед ней нужно поставить символы //, а для
отключения целого блока из нескольких операторов удобнее использовать многострочный
комментарий, который начинается символами /* и заканчивается символами */ (здесь и далее
многоточие означает «какие-то команды»):
main()
{
int i, X;
printf("Введите целое число:\n");
scanf("%d", &X);
// X *= X + 2;
for(i=1; i<10; i++) X *= i;
/* while ( X > 5 ) {
i = i * X;
} */
...
}
Пошаговое выполнение
Обычно программа выполняет-
ся безостановочно от начала до кон-
ца. Лучший способ отладки — это
выполнить программу по строчкам,
останавливаясь после выполнения
Щелкнуть здесь
каждой команды и проверяя значения (или Ctrl+F5)
переменных в памяти. Для этой цели точка останова
служат специальные программы —
отладчики.
С оболочкой Dev-C++ постав-
ляется отладчики GDB. Сначала
нужно установить точки останова,
то есть отметить строки, где нужно
остановить программу. Для этого
достаточно щелкнуть мышкой слева
от нужной строчки программы на
черном фоне. Повторный щелчок снимает точку останова в этом месте. Кроме того, с помощью
комбинации клавиш Ctrl+F5 можно устанавливать и снимать точку останова в том месте, где
стоит курсор.
Когда в программе есть хотя бы одна точка останова, можно запустить ее в отладочном
режиме, нажав кнопку F8. Отладчик должен остановить программу на первой встретившейся
29
точке останова. После этого можно выполнять программу в пошаговом режиме (по одной
строчке), нажимая клавишу F7.
Однако в этом режиме отладчик не позволяет входить внутрь вызываемых процедур (по
шагам выполняется только основная программа). Для входа в процедуру или функцию исполь-
зуют комбинацию Shift+F7.
При нажатии клавиш Ctrl+F7 отладчик запускает программу до следующей точки остано-
ва. Завершить отладку можно с помощью комбинации клавиш Ctrl+Shift+F2.
Просмотр значений переменных

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

Если другие способы не помогают, приходится делать ручную прокрутку программы, то
есть выполнять программу вручную вместо компьютера, записывая результаты на лист бумаги.
Обычно составляют таблицу, в которую записывают изменения всех переменных (неиз-
вестное значение переменной обозначают знаком вопроса). Рассмотрим (ошибочную) програм-
му, которая вводит натуральное число и определяет, простое оно или нет. Мы выяснили, что
она дает неверный результат при N=5 (печатает, что 5 – якобы составное число). Построим таб-
лицу изменения значений переменных для этого случая.
#include <stdio.h>
main()
{
int N, i, count = 0;
printf("Введите число "); N i count
scanf("%d", &N);
5 ? 0
for ( i = 2; i <= N; i ++ ) 2
if ( N %i == 0 ) 3
count ++; 4
if ( count == 0 ) 5 1
printf("Число простое");
else printf("Число составное");
}
Выполняя вручную все действия, выясняем, что программа проверяет делимость числа N на
само себя, то есть, счетчик делителей count всегда будет не равен нулю. Теперь, определив
30
причину ошибки, легко ее исправить. Для этого достаточно заменить условие в цикле на
i < N.
Проверка крайних значений

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

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

просто открывает специальное окно для рисования, ждет нажатия клавиши и закрывает это ок-
но. Программа эта так же неполноценна, как сэндвич без мяса.
#include <graphics.h>
#include <conio.h>
main()
{
initwindow ( 400, 300 ); // открыть окно для графики 400 на 300
// ... здесь можно рисовать на экране («мясо»)
getch(); // ждем нажатия клавиши
closegraph(); // закрыть окно
}
• Для использования графических функций надо подключить заголовочный файл
graphics.h.
• Функция initwindow открывает дополнительное окно, в котором можно рисовать. В
скобках нужно указать ширину и высоту этого окна в пикселях.
• Окно с графикой закрывается с помощью функции closegraph.
Как начать рисовать?

Координаты точек
Пришло время нарисовать что-то на экране. Для этого надо пред- X
ставлять, как определять координаты. (0,0)
• Начало координат, точка (0,0), находится в левом верхнем y
углу окна.
• Ось X направлена вправо, ось Y — вниз (в отличие от обще- x ( x, y )
принятой математической системы координат).
• Для любой точки координата x – это расстояние до левой Y
границы окна, а y – расстояние до верхней границы.
32
Цвет
Для 16 стандартных цветов заданы числовое и символьное обозначения:
0 BLACK черный 8 DARKGRAY темно-серый
1 BLUE синий 9 LIGHTBLUE светло-синий
2 GREEN зеленый 10 LIGHTGREEN светло-зеленый
3 CYAN морской волны 11 LIGHTCYAN светлый морской волны
4 RED красный 12 LIGHTRED светло-красный
5 MAGENTA фиолетовый 13 LIGHTMAGENTA светло-фиолетовый
6 BROWN коричневый 14 YELLOW желтый
7 LIGHTGRAY светло-серый 15 WHITE белый
Кроме того, можно использовать полную палитру цветов (режим True Color, истинный цвет). В
этом случае цвет строится из трех составляющих: красной (R) , зеленой (G) и синей (B). Каждая
из этих составляющих – целое число от 0 до 255 (256 вариантов), таким образом, всего получа-
ется 2563 = 16 777 216 цветов. Цвета строятся с помощью функции COLOR, у нее в скобках пе-
речисляются через запятую значения составляющих R , G и B (именно в таком порядке). Вот,
например, некоторые цвета:
COLOR(0,0,0) черный
COLOR(255, 0, 0) красный
COLOR(0, 255, 0) зеленый
COLOR(0, 0, 255) синий
COLOR(255, 255, 255) белый
COLOR(100, 100, 100) серый
COLOR(255, 0, 255) фиолетовый
COLOR(255, 255, 0) желтый
Функция setcolor устанавливает цвет линий:
setcolor ( 10 ); // установить светло-зеленый цвет
Все линии (а также прямоугольники, окружности), нарисованные после этой команды, будут
светло-зеленого цвета. Эта же функция может установить цвет из полной палитры:
setcolor ( COLOR(255,0,255) ); // установить фиолетовый цвет
Когда открывается окно для графики, по умолчанию (то есть без дополнительных действий)
устанавливается белый цвет.
Работа с отдельными пикселями

Для рисования используются стандартные функции. Для каждого пикселя можно задать свой
цвет с помощью функции putpixel:
putpixel ( x, y, 14 ); // покрасить точку (x,y) в желтый цвет
Функция getpixel позволяет определить цвет любого пикселя окна:
n = getpixel(x, y); // записать цвет точки (x,y) в переменную n
Линии
Отрезок можно нарисовать с помощью команды line:
line ( x1, y1, x2, y2 ); // отрезок (x1,y1)-(x2,y2)
Есть и другой способ: сначала перевести курсор (указатель текущего положения) в точку
(x1,y1) командой moveto, а затем нарисовать отрезок в точку (x2,y2) командой lineto:
33
moveto ( x1, y1 ); // курсор в точку (x1,y1)
lineto ( x2, y2 ); // отрезок в точку (x2,y2)
После выполнения команды lineto курсор смещается в новую точку (x1, y1) (x2, y2)
(x2,y2). Особенно удобно использовать эти команды при рисовании
ломаных линий:
(x5, y5) (x3, y3)
setcolor(12); // красный цвет
moveto (x1, y1); // курсор в первую точку
lineto (x2, y2); // отрезок во вторую точку (x4, y4)
lineto (x3, y3); // и т.д.
lineto (x4, y4);
lineto (x5, y5);
Прямоугольники
Для рисования прямоугольника нужно задать координаты двух проти-
(x1, y1)
воположных углов (обычно выбирают левый верхний и правый ниж-
ний углы). Цвет контура устанавливается с помощью функции
setcolor, а сам прямоугольник рисуется командой rectangle: (x2, y2)
setcolor ( 9 ); (x1, y1)
rectangle (x1, y1, x2, y2);
Закрашенный прямоугольник рисует команда bar. Цвет и стиль залив- (x2, y2)
ки нужно заранее установить, вызвав функцию setfillstyle:
setfillstyle ( 1, 12 ); // стиль 1, цвет 12
bar (x1, y1, x2, y2);
Первое число в команде setfillstyle задает стиль заливки:
0 – отключить заливку
1 – сплошная заливка
3,4,5,6 – наклонные линии
7,8 – сетка
9,10,11 – точечные узоры
а второе – цвет.
Окружность
Чтобы нарисовать окружность, используют функцию circle:
setcolor ( COLOR(0,255,0) ); // зеленый цвет
circle ( x, y, R );
При вызове функции circle в скобках указывают координаты центра и радиус окружности в
пикселях. Это могут быть числа, имена переменных или арифметические выражения, напри-
мер:
circle ( 200, y0+20, R );
Заливка произвольной области

Иногда бывает нужно залить каким-то цветом произвольную область, огра-
ниченную контуром одного цвета. Это можно сделать с помощью функции (x, y)
floodfill:
setfillstyle ( 1, 11 ); // стиль 1, цвет 11
floodfill (x, y, 0); // до границы цвета 0
34
Для заливки нужно знать координаты (x,y) одной (любой!) точки внутри этой области. Кроме
того, нужно, чтобы граница области была одного цвета, без разрывов. Цвет границы указывает-
ся последним в списке данных, которые передаются функции floodfill.
Надписи
(x, y)
Функция outtextxy позволяет выводить текст в любом месте окна. Ей
нужно задать координаты (x,y) левого верхнего угла текста. Цвет текста Вася
устанавливается с помощью функции setcolor:
setcolor ( 9 );
outtextxy ( x, y, "Вася" );
Пример программы (200, 50)
Напишем программу, которая использует стандартные функции (100, 100)
для рисования домика. Попытайтесь разобраться в ней самостоятельно.

#include <conio.h>
(300, 200)
main() Sharik's house
{
initwindow (440, 300);
setfillstyle (1, 9);
bar (100,100,300,200); // синий прямоугольник
setcolor (13); // с фиолетовой рамкой
rectangle (100,100,300,200);
moveto (100,100); // крыша-ломаная
lineto (200, 50);
lineto (300,100);
setfillstyle (1, 14); // зальем крышу желтым
floodfill (200, 75, 13);
setcolor (15);
circle (200, 150,50); // белая окружность
setfillstyle (1, 10);
floodfill (200,150, 15); // зеленая заливка
setcolor (12);
outtextxy (100, 230, "Sharik's house.");
getch();
closegraph();
}
35
7. Процедуры
Пример задачи с процедурой

Часто в программах бывает легко выделить одинаковые эле-
менты (например, одинаковые фигуры в рисунке). Составим про-
грамму, которая рисует на экране три одинаковых треугольника
разного цвета.
Конечно, можно нарисовать отдельно три фигуры «вручную»,
но хочется как-то облегчить работу, используя их сходство.
Сначала нужно определить, что общего имеют эти фигуры
(размеры, угол поворота) и в чем их отличие (цвет заливки, координаты). Если размеры тре-
угольников и угол поворота известны, то для построения треугольника достаточно знать коор-
динаты одной (любой) его точки (удобно выбрать одну из вершин).
Пусть (x,y) – координаты левого нижнего угла, ширина основания и
(x, y-60)
высота равны соответственно 100 и 60. Тогда легко подсчитать коор-
60 динаты остальных вершин: (x,y-60) и (x+100,y). Здесь мы учли,
что ось Y направлена вниз.
(x, y) 100 (x+100, y) Введем новую команду Tr, которая будет рисовать треугольник.
Вызывать ее будем так:
Tr ( x, y, c );
Здесь c – это цвет заливки треугольника.
Вся проблема в том, что компьютер (вернее, программа-транслятор) не знает такой ко-
манды и не сможет ее выполнить (выдать ошибку «Неизвестная функция»). Значит, нужно объ-
яснить эту команду, расшифровать ее через уже известные команды. Расшифровку мы офор-
мим так:
void Tr ( int x, int y, int c )
{
moveto ( x, y ); // курсор в левый нижний угол
lineto ( x, y-60 ); // рисуем контур
lineto ( x+100, y );
lineto ( x, y );
setfillstyle ( 1, c ); // устанавливаем цвет заливки
floodfill ( x+20, y-20, 15); // заливка до белой границы
}
Новые команды, введенные таким образом, в программировании называются подпрограммами
(вспомогательными программами) или процедурами.
Процедура – это вспомогательная программа (подпрограмма), предназначенная для выпол-
нения каких-либо действий, которые встречаются в нескольких местах программы.
Процедура оформляется почти так же, как и основная программа, только ее имя – не
main, а какое-то другое. Она состоит из заголовка, после которого внутри фигурных скобок
записывают тело процедуры – те команды, которые выполняются при вызове. Эти команды
должны уже быть известны транслятору.
Рассмотрим подробно заголовок процедуры
36
Слово void означает, что эта команда выполняет какие-то действия (например, что-то рисует),
а не вычисляет какое-то значение2. В скобках через запятую перечисляются параметры проце-
дуры.
Параметры – это дополнительные данные для работы процедуры.
Можно сделать процедуру без параметров, но она будет всегда выполнять совершенно одина-
ковые действия. Например, всегда будет рисовать синий треугольник в одном и том же месте.
Параметры дают возможность менять результат работы процедуры – перемещать фигуру (из-
меняя параметры x и y) и задавать разные цвета заливки (меняя па-
раметр c). 60
Вспомните, что мы включили в параметры все, что изменяет-
ся. Эти данные заранее неизвестны, поэтому они обозначаются име- (100,100)
нами (переменными) и называются формальными параметрами. В
заголовке процедуры для каждого параметра указывается его тип,
как при объявлении переменных. 100
Как же использовать такую процедуру? Предположим, что левый нижний угол синего
треугольника нужно разместить в точке (100,100). Учитывая, что длина основания тре-
угольника и его высота равны соответственно 100 и 60, находим координаты соответствующих
углов двух других треугольников: (200,100) для зеленого и (200,160) для красного. Решение
нашей задачи выглядит так:
#include <conio.h>
{
moveto ( x, y ); // курсор в левый нижний угол
lineto ( x, y-60 ); // рисуем контур
lineto ( x+100, y );
lineto ( x, y );
setfillstyle ( 1, c ); // устанавливаем цвет заливки
floodfill ( x+20, y-20, 15); // заливка до белой границы
}
main()
{
Tr (100, 100, COLOR(0,0,255));
Tr (200, 100, COLOR(0,255,0));
Tr (200, 160, COLOR(255,0,0));
getch();
closegraph();
}
Посмотрим на программу внимательно. Процедура (расшифровка, описание новой команды)
расположена выше основной программы. Она оформлена в виде отдельного блока, не внутри
основной программы, а рядом с ней. Строчка
Tr (100, 100, COLOR(0,0,255));
это вызов процедуры. В скобках указаны фактические значения всех параметров (фактические
параметры). При таком вызове первое значение (100) подставляется в процедуру вместо пер-
вого параметра – x, второе значение – вместо второго параметра и т.д. Важно, что к моменту
2
Позднее мы изучим подпрограммы, которые возвращают значение-результат – они называются функциями.
37
обработки этой строчки транслятор уже знает процедуру Tr, поскольку она была объявлена
выше.
Чтобы нарисовать оставшиеся два треугольника, нам не нужно заново два раза писать все
команды, вошедшие в процедуру, а достаточно вызвать процедуру еще два раз, с другими па-
раметрами:
Tr (200, 100, COLOR(0,255,0));
Tr (200, 160, COLOR(255,0,0));
• Процедура оформляется так же, как основная программа: заголовок и тело процедуры в фи-
гурных скобках.
• Перед именем процедуры ставится слово void. Это означает, что она предназначена не
для вычислений, а для выполнения некоторых действий.
• После имени в скобках через запятую перечисляются параметры процедуры — те величи-
ны, от которых зависит ее работа. Параметры иногда называют аргументами процедуры.
• Для каждого параметра отдельно указывается его тип (int, float, char).
• Имена параметров можно выбирать любые, допустимые в языке Си.
• Параметры, перечисленные в заголовке процедуры, называются формальными — это зна-
чит, что они доступны только внутри процедуры при ее вызове.
• Желательно выбирать осмысленные имена параметров процедуры — это позволяет легче
разобраться в программе потом, когда уже все забыто.
• При вызове процедуры надо указать ее имя и в скобках фактические параметры, которые
подставляются в процедуре вместо формальных параметров.
• Фактические параметры — это числа или любые арифметические выражения (в этом случае
сначала рассчитывается их значение).
• Первый фактический параметр подставляется в процедуре вместо первого формального па-
раметра, и т.д.
• Процедура должна быть объявлена до основной программы; чтобы к моменту вызова проце-
дуры транслятор знал, что есть такая процедура, а также сколько она имеет параметров и ка-
ких. Это позволяет находить ошибки на этапе трансляции, например такие:
Tr ( 100 ); Too few arguments (слишком мало параметров).

Tr (100, 100, 5, 5); Too many arguments (слишком много…).
• Часто процедуры вызываются только один раз — в этом случае их задача — разбить боль-
шую основную программу (или процедуру) на несколько самостоятельных частей, посколь-
ку рекомендуется, чтобы каждая процедура была длиной не более 50 строк (2 экрана по 25
строк), иначе очень сложно в ней разобраться.
• Для досрочного выхода из процедуры используется оператор return, при его выполнении
работа процедуры заканчивается.
• В процедуре можно использовать несколько операторов return: при выполнении любого из
них работа процедуры заканчивается.
38
8. Функции
Отличие функций от процедур

Теперь мы познакомимся ещё с одним типом подпрограмм – с функциями. Функции, так-
же как и процедуры, предназначены для выполнения одинаковых операций в разных частях
программы. Они имеют одно существенное отличие: задача функции – вычислить и вернуть в
вызывающую программу значение-результат (в простейшем случае это целое, вещественное
или символьное значение).
Функция – это вспомогательная программа (подпрограмма), предназначенная для получе-
ния некоторого объекта-результата (например, числа). Она также может выполнять какие-то
полезные действия.
Покажем использование функции на примере. Решим задачу, которую мы уже решали раньше.
Задача. Написать программу, которая вводит целое число и определяет сумму его цифр. Ис-
пользовать функцию, вычисляющую сумму цифр числа.
Вспомним, что для того чтобы найти последнюю цифру числа, надо взять остаток от его деле-
ния на 10. Затем делим число на 10, отбрасывая его последнюю цифру, и т.д. Сложив все эти
остатки-цифры, мы получим сумму цифр числа.
#include <stdio.h>
#include <conio.h>
int SumDigits ( int N ) // заголовок функции
{ // начало функции
int d, sum = 0;
while ( N != 0 )
{
d = N % 10; // тело функции
sum = sum + d;
N = N / 10;
}
return sum; // функция возвращает значение sum
} // конец функции
main()
{
int N, s;
printf ( "\nВведите целое число ");
scanf ( "%d", &N );
s = SumDigits (N); // вызов функции
printf ( "Сумма цифр числа %d равна %d\n", N, s );
getch();
}
• Функция оформляется так же, как процедура: заголовок и тело функции в фигурных скобках.
• Перед именем функции ставится тип результата (int, float, char, и т.д.) — это озна-
чает, что она возвращает значение указанного типа.
39
• После имени в скобках через запятую перечисляются параметры функции — те величины,
от которых зависит ее работа.
• Для каждого параметра отдельно указывается его тип (int, float, char).
• Имена параметров можно выбирать любые, допустимые в языке Си.
• Параметры, перечисленные в заголовке функции, называются формальными — это значит,
что они доступны только внутри функции при ее вызове.
• Желательно выбирать осмысленные имена параметров — это позволяет легче разобраться в
программе потом.
• При вызове функции надо указать ее имя и в скобках фактические параметры, которые ис-
пользуются внутри функции вместо формальных параметров.
• Фактические параметры — это числа или любые арифметические выражения (в этом случае
сначала рассчитывается их значение).
• Первый фактический параметр используется внутри функции вместо первого формального
параметра, и т.д.
• Для того, чтобы определить значение функции, используется оператор return, после кото-
рого через пробел записывается возвращаемое значение – число или арифметическое выра-
жение. Примеры:
return 34;
return s;
return a + 4*b - 5;
При выполнении оператора return работа функции заканчивается.
• В функции можно использовать несколько операторов return.
• Если функции расположены ниже основной программы, их необходимо объявить до основ-
ной программы. Для объявления функции надо написать ее заголовок с точкой с запятой в
конце.
• При объявлении функции после заголовка ставится точка с запятой, а в том месте, где запи-
сано тело функции — не ставится.
Логические функции
Очень часто надо составить функцию, которая просто решает какой-то вопрос и отвечает
на вопрос «Да» или «Нет». Такие функции называются логическими. Вспомним, что в Си ноль
означает ложное условие, а единица – истинное.
Логическая функция – это функция, возвращающая 1 (если ответ «Да») или 0 (если ответ
«Нет»).
Логические функции используются, главным образом, в двух случаях:
• если надо проанализировать ситуацию и ответить на вопрос, от которого зависят дальнейшие
действия программы;
• если надо выполнить какие-то сложные операции и определить, была ли при этом какая-то
ошибка.
40
Простое число или нет?
Задача. Ввести число N и определить, простое оно или нет. Использовать функцию, которая
отвечает на этот вопрос.
Теперь расположим тело функции ниже основной программы. Чтобы транслятор знал об
этой функции во время обработки основной программы, надо объявить её заранее.
#include <stdio.h>
#include <conio.h>
int Prime ( int N ); // объявление функции
main()
{
int N;
printf ( "\nВведите целое число ");
scanf ( "%d", &N );
if ( Prime(N) ) // вызов функции
printf ( "Число %d - простое\n", N );
else printf ( "Число %d - составное\n", N );
getch();
}
int Prime ( int N ) // описание функции
{
for ( int i = 2; i*i <= N; i ++ )
if ( N % i == 0 ) return 0; // нашли делитель – составное!
return 1; // не нашли ни одного делителя – простое!
}
Функции, возвращающие два значения

По определению функция может вернуть только одно значение-результат. Если надо вер-
нуть два и больше результатов, приходится использовать специальный прием — передачу па-
раметров по ссылке.
Задача. Написать функцию, которая определяет максимальное и минимальное из двух целых
чисел.
В следующей программе используется достаточно хитрый прием: мы сделаем так, чтобы функ-
ция изменяла значение переменной, которая принадлежит основной программе. Один результат
(минимальное из двух чисел) функция вернет как обычно, а второй – за счет изменения пере-
менной, которая передана из основной программы.
#include <stdio.h> параметр-результат
#include <conio.h>
int MinMax ( int a, int b, int &Max )
{
if ( a > b ) { Max = a; return b; }
else { Max = b; return a; }
}
main()
{
int N, M, min, max;
printf ( "\nВведите 2 целых числа ");
scanf ( "%d%d", &N, &M );
41
min = MinMax ( N, M, max ); // вызов функции
printf ( "Наименьшее из них %d, наибольшее — %d\n", min, max );
getch();
}
Обычно при передаче параметра в процедуру или функцию в памяти создается копия перемен-
ной, и функция работает с этой копией. Это значит, что все изменения переменной-параметра,
сделанные в функции, не отражаются на значении этой переменной в вызывающей программе.
Если перед именем параметра в заголовке функции поставить знак & (вспомним, что он
также используется для определения адреса переменной), то функция работает прямо с пере-
менной из вызывающей программы, а не с ее копией. Поэтому в нашем примере функция изме-
нит значение переменой max из основной программы и запишет туда максимальное из двух
чисел.
Этот приём можно использовать и для процедур: хотя формально они не возвращают ни-
какого значения-результата, можно всё-таки передавать данные в вызывающую программу че-
рез изменяемые параметры.
• Если надо, чтобы функция вернула два и более результатов, поступают следующим образом:
o один результат передается как обычно с помощью оператора return
o остальные возвращаемые значения передаются через изменяемые параметры
• Обычные параметры не могут изменяться подпрограммой, потому что она работает с копия-
ми параметров (например, если менять значения a и b в функции MinMax, соответствующие
им переменные N и M в основной программе не изменятся).
• Любая процедура и функция может возвращать значения через изменяемые параметры.
• Изменяемые параметры (или параметры, передаваемые по ссылке) объявляются в заголовке
подпрограммы специальным образом: перед их именем ставится знак & — в данном случае
он означает ссылку, то есть подпрограмма может менять значение параметра (в данном слу-
чае функция меняет значение переменной max в основной программе).
• При вызове таких функций и процедур вместо каждого фактического изменяемого параметра
надо подставлять только имя переменной (не число и не арифметическое выражение — в
этих случаях транслятор выдает предупреждение и формирует в памяти временную пере-
менную).
42
9. Структура программ
Составные части программы
В составе программы можно выделить несколько частей:
• Подключение заголовочных файлов — это строки, которые начинаются с #include
• Объявление констант (постоянных величин):
const N = 20;
• Глобальные переменные — это переменные, объявленные вне основной программы и под-
программ. К таким переменным могут обращаться все процедуры и функции данной про-
граммы (их не надо еще раз объявлять в этих процедурах).
• Объявление функций и процедур — обычно ставятся выше основной программы. По тре-
бованиям языка Си в тот момент, когда транслятор находит вызов подпрограммы, она
должна быть объявлена и известны типы всех ее параметров.
• Основная программа может располагаться как до всех подпрограмм, так и после них. Не
рекомендуется вставлять ее между подпрограммами, так как при этом ее сложнее найти.
Глобальные и локальные переменные

Глобальные переменные доступны из любой процедуры или функции. Поэтому их надо
объявлять вне всех подпрограмм. Остальные переменные, объявленные в процедурах и функ-
циях, называются локальными (местными), поскольку они известны только той подпрограмме,
где они объявлены. Следующий пример показывает различие между локальными и глобальны-
ми переменными.
#include <stdio.h>
int var = 0; // объявление глобальной переменной
void ProcNoChange ()
{
int var; // локальная переменая
var = 3; // меняется локальная переменая
}
void ProcChange1 ()
{
var = 5; // меняется глобальная переменая
}
void ProcChange2 ()
{
int var; // локальная переменая
var = 4; // меняется локальная переменная
::var = ::var * 2 + var; // меняется глобальная переменная
}
main()
{
ProcChange1(); // var = 5;
ProcChange2(); // var = 5*2 + 4 = 14;
ProcNoChange(); // var не меняется
printf ( "%d", var ); // печать глобальной переменной (14)
}
43
• Глобальные переменные не надо заново объявлять в подпрограммах.
• Если в подпрограмме объявлена локальная переменная с таким же именем, как и гло-
бальная переменная, то используется локальная переменная.
• Если имена глобальной и локальной переменных совпадают, то для обращения к гло-
бальной переменной в подпрограмме перед ее именем ставится два двоеточия:
глобальная локальная
::var = ::var * 2 + var;

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

Зачем оформлять программы?
Зачем же красиво и правильно оформлять тексты программ? На этот вопрос вы сможете отве-
тить сами, сравнив две абсолютно одинаковые (с точки зрения транслятора) программы:
#include <stdio.h> #include <stdio.h> main()
main() { float x, y; printf (
{ "\nВведите 2 числа " );
float x, y; scanf ( "%d%d", &x, &y );
printf ("\nВведите 2 числа "); printf ( "Их сумма %d ",
scanf ("%d%d", &x, &y); x+y );}
printf ("Их сумма %d ", x+y);
}
То, что в них отличается и называется грамотным оформлением (очевидно, что оно присутству-
ет в первой программе).
Оформление текста программы необходимо для того, чтобы
• отлаживать программу (искать и исправлять ошибки в ней)
• разбираться в алгоритме работы программы
44
Оформление процедур и функций
При оформлении функций и процедур рекомендуется придерживаться следующих правил:
• Одинаковые операции в разных частях программы оформляются в виде подпрограмм.
• Имена функций и процедур должны быть информативными, то есть нести информацию о
том, что делает эта подпрограмма. К сожалению, транслятор не понимает русские имена,
поэтому приходится писать по-английски. Если вам сложно писать имена на английском
языке, можно писать русские слова английскими буквами. Например, процедуру, рисую-
щую квадрат, можно объявить так:
void Square ( int x, int y, int a );
или так
void Kvadrat ( int x, int y, int a );
• Перед заголовком подпрограммы надо вставлять несколько строк с комментарием (здесь
можно писать по-русски). В комментарий записывается самая важная информация: что
означают параметры подпрограммы, что она делает, какое значение она возвращает (если
это функция), её особенности.
• Не рекомендуется делать подпрограммы длиной более 25-30 строк, так как при этом они
становятся сложными и запутанными. Если подпрограмма получается длинной, ее надо
разбить на более мелкие процедуры и функции.
• Чтобы отделить одну часть подпрограммы от другой, используют пустые строки. Круп-
ный смысловой блок функции можно выделять строкой знаков минус в комментариях.
Приведем пример оформления на примере функции, которая рисует на экране закрашенный
ромб с заданными параметрами, если весь ромб умещается на экран (при этом результат функ-
ции равен 1), или возвращает признак ошибки (число 0).
//**********************************************
// ROMB — рисование ромба в заданной позиции
заголовок
// (x,y) — координаты центра ромба
// a, b — ширина и высота ромба
// color, colorFill — цвета границы и заливки
// Возвращает 1, если операция выполнена, и 0 если
// ромб выходит за пределы экрана
//**********************************************
обработка
int Romb ( int x, int y, int a, int b, int color,
ошибок
int colorFill )
{
if ( (x < a) || (x > 640-a) || (y < b) || (y > 480-b) )
return 0;
//------------------------------------ крупный блок
setcolor ( color );
line ( x-a, y, x, y-b ); line ( x-a, y, x, y+b );
line ( x+a, y, x, y-b ); line ( x+a, y, x, y+b );
setfillstyle ( SOLID_FILL, colorFill ); пустая строка

floodfill ( x, y, color );
return 1;
}
45
Отступы
Отступы используются для выделения структурных блоков программы (подпрограмм,
циклов, условных операторов). Отступы позволяют легко искать лишние и недостающие скоб-
ки, понимать логику работы программы и находить в ней ошибки. При расстановке отступов
рекомендуется соблюдать следующие правила:
• Величина отступа равна 2-4 символа.
• Дополнительным отступом выделяются
o тело циклов for, while, do-while
o тело условного оператора if и блока else
o тело оператора множественного выбора switch
Вот пример записи программы с отступами (запись «лесенкой»):
main()
{
int a = 1, b = 4, i;
for (i=1; i<2; i++)
{
if ( a > b )
{
b = a + i;
}
else
{
a = b + i;
}
}
printf ( "%d %d\n", a, b );
}
46
10. Анимация
Что такое анимация?

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

• двигать объект так, чтобы он мигал как можно меньше
• обеспечить управление клавишами или мышкой во время движения
В этом разделе рассматриваются самые простые задачи этого типа. Во всех программах преду-
смотрен выход по клавише Esc.
Движение объекта
Составим программу, которая передвигает по экрану какой-то объект (в
нашем случае – квадрат) от левой границы экрана к правой. Программа закан-
чивает работу, когда объект вышел за границы экрана или была нажата клави-
ша Esc.
Предварительный анализ
Рассмотрим объект, который движется по экрану. Пусть это будет
(x, y) квадрат со стороной 20 пикселей. При движении координаты всех его точек
будут меняться. Чтобы строить квадрат в любом месте экрана, мы выберем
его левый верхний угол в качестве базовой (опорной) точки и обозначим ее
(x+20, y+20) координаты за (x,y). Координаты противоположного угла будут равны
(x+20,y+20).
Теперь надо придумать способ изобразить движение так, чтобы рисунок не мигал, и про-
грамма работала одинаково на всех компьютерах независимо от быстродействия. Для этого
применяют такой алгоритм:
1) рисуем фигуру на экране;
2) делаем небольшую задержку (обычно 10-20 мс);
3) стираем фигуру;
4) меняем ее координаты;
5) переходим к шагу 1.
Эти действия повторяются до тех пор, пока не будет получена команда «закончить дви-
жение» (в нашем случае – нажата клавиша Esc или объект вышел за правую границу экрана).
Пусть движение прямоугольника происходит на синем фоне. Тогда самый быстрый и про-
стой способ стереть его – это нарисовать его же, но синим цветом. Поэтому удобно написать
процедуру, параметрами которой являются координаты x и y, а также цвет color. Когда мы
используем синий цвет, фигура стирается с экрана.
void Draw( int x, int y, int color )
{
setfillstyle ( 1, color ); // сплошная заливка, цвет color
bar ( x, y, x+20, y+20 ); // залитый прямоугольник
}
Обратите внимание, что эта процедура умеет рисовать и стирать квадрат.

47
Все действия, которые входят в алгоритм, надо выполнить много раз, поэтому применим
цикл. Кроме того, мы заранее не знаем, сколько раз должен выполниться этот цикл, поэтому
применяем цикл while (цикл с условием).
Условие окончания цикла – выход фигуры за границы экрана или нажатие на клавишу
Esc. Мы будем использовать окно размером 400 на 400 пикселей. При этом координата x может
меняться от 0 до 399, поэтому нужное нам условие продолжения цикла выглядит так:
x + 20 < 400
Когда это условие нарушается, квадрат «уехал» за границу окна и нужно закончить выполнение
программы.
Обработка событий клавиатуры

Надо также обеспечить выход по клавише Esc. При этом объект должен двигаться и нельзя
просто ждать нажатия на клавишу с помощью функции getch. В этом случае используют сле-
дующий алгоритм:
1. Проверяем, нажата ли какая-нибудь клавиша; это делает функция kbhit, которая воз-
вращает результат 0 (ответ «нет»), если никакая клавиша не нажата, и ненулевое значе-
ние, если нажали любую клавишцу. В программе проверка выполнена с помощью ус-
ловного оператора
if ( kbhit() ) { ... }
2. Если клавиша нажата, то
• Определяем код этой клавиши, вызывая функцию getch. Код клавиши – это ее но-
мер в таблице символов. Если на символ отводится 1 байт памяти, то всего можно ис-
пользовать 256 разных символов и их коды изменяются в интервале от 0 до 255.
• Если полученный код равен коду клавиши Esc (27), то выходим из цикла
Для того, чтобы управлять программой с помощью клавиш, нужно знать их коды. Вот некото-
рые из них
Esc 27
Enter 13
пробел 32
Программа
Программа «в сборе» выглядит так:
#include <conio.h>
void Draw ( int x, int y, int color )
{
setfillstyle ( 1, color ); // сплошная заливка, цвет color
bar ( x, y, x+20, y+20 ); // залитый прямоугольник
}
main()
{
int x, y; // координаты квадрата
initwindow (400, 400); // открыть окно для графики
setfillstyle(1, COLOR(0,0,255)); // сплошная заливка, синий цвет
bar (0, 0, 399, 399); // залить фон
x = 0; y = 240; // начальные координаты квадрата
/* анимация */
closegraph(); // закрыть окно для графики
}
48
Осталось лишь дописать основной блок, который обозначен в программе комментарием
/* анимация */
В нем нужно организовать цикл анимации, который заканчивается тогда, когда квадрат коснул-
ся границ окна или нажата клавиша Esc.
while ( x + 20 < 400 ) // пока не коснулся границы окна
{
if ( kbhit() ) // если нажата клавиша...
if ( getch() == 27 ) break; // если Esc, выход из цикла
Draw ( x, y, COLOR(255,255,0) ); // рисуем желтый квадрат
delay ( 20 ); // смотрим на него (задержка)
Draw ( x, y, COLOR(0,0,255) ); // стираем
x ++; // перемещаем
}
Цикл while выполняется до тех пор, пока фигура находится в пределах экрана. Нажатие
на клавишу Esc обрабатывается внутри цикла. Сначала мы определяем, нажата ли какая-нибудь
клавиша (с помощью функции kbhit), затем определяем ее код (функция getch) и, если он
равен коду клавиши Esc, выходим из цикла с помощью оператора break.
В основной части цикла рисуем фигуру с помощью процедуры, затем делаем задержку на
20 мс, вызывая функцию delay с параметром 20, и затем стираем фигуру. После этого изменя-
ем координату x и возвращаемся к началу цикла.
• Чтобы определить нажата ли какая-нибудь клавиша, используется функция kbhit. Она
возвращает 0, если никакая клавиша не нажата, и ненулевое значение, если была нажата
какая-то клавиша.
• Если клавиша уже была нажата, ее код можно получить (без дополнительного ожидания)
с помощью функции getch.
• Чтобы сделать задержку на заданное время, используется процедура delay. Параметром
этой процедуры является величина задержки в миллисекундах. Если уменьшать задержку,
фигура будет двигаться быстрее.
Управление клавишами-стрелками
Предварительный анализ
Принцип работы программы очень простой: получив код клавиши, надо сдвинуть объект в со-
ответствующую сторону. Если обозначить изменения координат фигуры x и y за 1 шаг цикла
через dx и dy, для движения в четырех направлениях получаем:
движение влево dx < 0, dy = 0
движение вправо dx > 0, dy = 0
движение вверх dx = 0, dy < 0
движение вниз dx = 0, dy > 0
Это значит, что надо сделать выбор одного из четырех вариантов в зависимости от кода нажа-
той клавиши. Для этого можно использовать несколько условных операторов if, но существу-
ет специальный оператор switch, который позволяет легко организовать выбор из нескольких
вариантов.
49
if switch
1 2 1 2 3 4
Еще одна проблема связана с тем, что клавиши управления курсором (стрелки) – не совсем
обычные клавиши. Они относятся к группе функциональных клавиш, у которых нет кодов в
таблице символов. Когда нажата одна из специальных клавиш, система реагирует на нее как на
2 нажатия, причем для первого код символа всегда равен нулю, а для второго мы получим спе-
циальный код (так называемый скан-код, номер клавиши на клавиатуре). Мы будем использо-
вать упрощенный подход, когда анализируется только этот второй код:
влево 75 вверх 72
вправо 77 вниз 80
У такого приема есть единственный недостаток: объект будет также реагировать на нажатие
клавиш с кодами 75, 77, 72 и 80 в таблице символов, то есть на заглавные латинские буквы K,
M, H и P.
Простейший случай
Составим программу, при выполнении которой фигура будет двигаться только тогда, ко-
гда мы нажмем на клавишу-стрелку. В цикле мы сначала рисуем фигуру, ждем нажатия на кла-
вишу и принимаем ее код с помощью функции getch. После этого стираем фигуру в том же
месте (пока не изменились координаты) и, в зависимости от этого кода, меняем координаты
фигуры нужным образом.
Здесь используется бесконечный цикл while(1). Выйти из него можно только одним
способом – через оператор break (досрочный выход из цикла).
while ( 1 ) // бесконечный цикл
{
Draw ( x, y, COLOR(255,255,0) ); // рисуем квадрат
code = getch(); // ждем нажатия клавиши
if ( code == 27 ) break; // если Esc, то выход
Draw ( x, y, COLOR(0,0,255) ); // стираем квадрат
switch ( code ) { // выбор направления
case 75: x --; break; // влево
case 77: x ++; break; // вправо
case 72: y --; break; // вверх
case 80: y ++; // вниз
}
}
В операторе switch значения координат меняются на единицу, хотя можно использовать лю-
бой шаг. В конце обработки каждого варианта надо ставить оператор break, чтобы не выпол-
нялись строки, стоящие ниже. Обратите внимание, что целую переменную code нужно объя-
вить в начале основной программы.
Непрерывное движение
Теперь рассмотрим более сложный случай, когда объект продолжает движение в выбран-
ном направлении даже тогда, когда ни одни клавиша не нажата, а при нажатии клавиши-
стрелки меняет направление. Здесь надо использовать переменные dx и dy, которые задают
направление движения. Сначала мы определяем, нажата ли клавиша, а затем определяем ее код,
50
записываем его в переменную code, и обрабатываем это нажатие с помощью оператора
switch.
dx = 1; dy = 0; // сначала двигается вправо
while ( 1 ) // бесконечный цикл
{
if ( kbhit() ) { // если нажата клавиша
code = getch(); // получить ее код
if ( code == 27 ) break; // если Esc, то выход
switch ( code ) { // изменить направление движения
case 75: dx = -1; dy = 0; break;
case 77: dx = 1; dy = 0; break;
case 72: dx = 0; dy = -1; break;
case 80: dx = 0; dy = 1;
}
}
Draw ( x, y, COLOR(255,255,0) ); // рисуем квадрат
delay ( 10 ); // ждем
Draw ( x, y, COLOR(0,0,255) ); // стираем
x += dx; // двигаем квадрат
y += dy;
}
51
11. Случайные и псевдослучайные числа
Что такое случайные числа?

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

Обычно используют псевдослучайные числа (далее для краткости мы называем их просто
случайными), находящиеся в некотором интервале. Например, представим себе, что снежинки
падают не на всю поверхность земли, а на отрезок оси OX от a до b. При этом очень важно
знать некоторые общие свойства этой последовательности. Если понаблюдать за снежинками в
безветренную погоду, то слой снега во всех местах будет примерно одинаковый, а при ветре —
разный. Про случайные числа в первом случае говорят, что они имеют равномерное распреде-
ление, а во втором случае — неравномерное.
равномерное неравномерное
распределение распределение
Большинство стандартных датчиков псевдослучайных чисел (то есть формул, по которым они
вычисляются) дают равномерное распределение в некотором интервале.
Поскольку случайные числа в компьютере вычисляются по формуле, то для того, чтобы
повторить в точности какую-нибудь случайную последовательность достаточно просто взять то
же самое начальное значение.
52
Функции для работы со случайными числами

В языке Си существуют следующие функции для работы со случайными числами (их
описание находится в заголовочном файле stdlib.h — это значит, что его необходимо под-
ключать в начале программы):
получить случайное целое число в интервале от 0 до
n = rand();
RAND_MAX (это очень большое целое число — 32767)
установить начальное значение случайной последова-

srand ( m );
тельности, равное m
Случайные числа в заданном интервале

Для практических задач надо получать случайные числа в заданном интервале [a,b]. Если
интервал начинается с нуля (a=0), можно использовать свойство операции взятия остатка от
деления: остаток от деления числа на некоторое N всегда больше или равен нуля, но меньше N,
то есть находиться в интервале [0,N-1]. Можно написать такую функцию
int random ( int N )
{
return rand() % N; // случайное число в интервале [0,N-1]
}
С ее помощью (вызывая ее много раз подряд) можно получать последовательность случайных
чисел в интервале [0,N-1] с равномерным распределением.
Теперь попытаемся использовать эту функцию для интервала [a,b]. Очевидно, что фор-
мула
k = random(N) + a;
дает последовательность в интервале [a,a+N-1]. Поскольку нам нужно получить интервал
[a,b], сразу имеем b=a+N-1, откуда N=b-a+1. Поэтому
Для получения случайных целых чисел с равномерным распределением в интервале [a,b]
надо использовать формулу
k = random(b-a+1) + a;
Более сложным оказывается вопрос о случайных вещественных числах. Если разделить

результат функции rand() на RAND_MAX:
x = (float) rand() / RAND_MAX;
мы получим случайное вещественное число в интервале [0,1) (при этом надо не забыть при-
вести одно из этих чисел к вещественному типу, иначе деление одного целого числа на большее
целое число будет всегда давать ноль).
Длина интервала [0,1) такой последовательности равна 1, а нам надо получить интер-
вал длиной b-a. Если теперь это число умножить на b-a и добавить к результату a, мы полу-
чаем как раз нужный интервал.
Для получения случайных вещественных чисел с равномерным распределением в интервале
[a,b) надо использовать формулу
x = rand()*(b-a)/RAND_MAX + a;
До этого момента мы говорили только о получении случайных чисел с равномерным рас-
пределением. Как же получить неравномерное? На этот вопрос математика отвечает так: из
53
равномерного распределения можно получить неравномерное, применив к этим данным неко-
торую математическую операцию. Например, чтобы основная часть чисел находилась в сере-
дине интервала, можно брать среднее арифметическое нескольких последовательных случай-
ных чисел с равномерным распределением.
Снег на экране
Приведенная ниже программа генерирует случайное значение x в интервале [0,399],
случайное значение y в интервале [0,299] и проверяет цвет точки с координатами (x,y).
Если эта точка черная, то ее цвет устанавливается случайный, а если нет — черный. Случайный
цвет строится с помощью стандартной функции COLOR из красной (R), зеленой (G) и синей (B)
составляющих, которые выбираются случайно в интервале [0,255].
#include <conio.h>
#include <stdlib.h>
int random (int N) { return rand() % N; } // функция
main()
{
int x, y, R, G, B;
while ( ! kbhit () ) { // пока не нажата клавиша
x = random(400); // случайные координаты
y = random(300);
R = random(256); // случайный цвет (R,G,B)
G = random(256);
B = random(256);
if ( getpixel(x,y) != 0 ) // если точка не черного цвета
putpixel ( x, y, 0 ); // делаем ее черной
else // иначе...
putpixel ( x, y, COLOR(R,G,B) ); // случайный цвет
}
getch();
closegraph();
}
• для определения того, была ли нажата какая-нибудь клавиша, используется функция
kbhit, которая возвращает 0, если клавиша не была нажата, и ненулевое значение, если
нажата любая клавиша. Для того, чтобы определить код этой клавиши, надо вызвать
функцию getch. Таким образом, цикл «пока не нажата клавиша» может выглядеть так:
while ( ! kbhit() ) { ... }

• для того, чтобы получить текущий цвет точки, используется функция getpixel.

Devcpp 1

Загружено:

Авторское право:

Доступные форматы

Devcpp 1

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Devcpp 1

Загружено:

Авторское право:

Доступные форматы

1

Программирование на языке Си. © К. Поляков, 1995-2012

 Зачем нужно программирование?

 Два этапа создания программ

Объектный файл: Стандартные

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

 Вывод текста на экран

• Для подключения заголовочных файлов используется директива (команда) препроцессо-

• Для вывода информации на экран используется функция printf. В простейшем случае

 Как запустить программу?

 Типы данных и переменные

int a; // выделить память под целую переменную a

 Вычисление суммы двух чисел (ввод и вывод)

scanf ( "%d%d", &a, &b );

• Для вычислений используют оператор присваивания, в котором

printf ( "Результат: %d + %d = %d \n", a, b, c );

При делении целого числа на целое остаток от деления отбрасывается, таким

 Приоритет арифметических операций

 Странные операторы присваивания

 Сокращенная запись арифметических выражений

 Форматы для вывода данных

Пример вывода Результат Комментарий

printf("[%f]", 123.45); [123.450000] Минимально возможное поле,

Пример вывода Результат Комментарий

Всего 10 позиций, из них 3

 Условный оператор if — else

Таблица истинности запишется в виде

• Порядок выполнения (приоритет) логических операций и отношений:

 Переключатель switch (множественный выбор)

 Зачем нужны циклы?

 Цикл с известным числом шагов (for)

 Чему равен квадрат числа?

 Цикл с условием (while)

while ( 1 ){ ... } // бесконечный цикл

 Цикл с постусловием (do — while)

 Досрочный выход из цикла

 Вычисление сумм последовательностей

 Суммы с ограничивающим условием

5. Методы отладки программ

 Отладочные средства Dev-C++

 Отключение части кода

 Просмотр значений переменных

 Ручная прокрутка программы

 Проверка крайних значений

6. Работа в графическом режиме

 Простейшая графическая программа

включение в графический режим хлеб

Сейчас мы напишем простейшую графическую программу. Она не делает ничего полезного,

 Как начать рисовать?

 Работа с отдельными пикселями

 Заливка произвольной области

 Пример программы (200, 50)

Напишем программу, которая использует стандартные функции (100, 100)

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

 Пример задачи с процедурой

Tr ( 100 ); Too few arguments (слишком мало параметров).

 Отличие функций от процедур

 Функции, возвращающие два значения

 Глобальные и локальные переменные

Зачем нужно программирование?

Два этапа создания программ

Вывод текста на экран

Как запустить программу?

Типы данных и переменные

Вычисление суммы двух чисел (ввод и вывод)

Приоритет арифметических операций

Странные операторы присваивания

Сокращенная запись арифметических выражений

Форматы для вывода данных

Условный оператор if — else

Переключатель switch (множественный выбор)

Зачем нужны циклы?

Цикл с известным числом шагов (for)

Чему равен квадрат числа?

Цикл с условием (while)

Цикл с постусловием (do — while)

Досрочный выход из цикла

Вычисление сумм последовательностей

Суммы с ограничивающим условием

Отладочные средства Dev-C++

Отключение части кода

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

Ручная прокрутка программы

Проверка крайних значений

Простейшая графическая программа

Как начать рисовать?

Работа с отдельными пикселями

Заливка произвольной области

Пример программы (200, 50)

Пример задачи с процедурой

Отличие функций от процедур

Функции, возвращающие два значения

Глобальные и локальные переменные

Оформление текста программы

Что такое анимация?

Обработка событий клавиатуры

Что такое случайные числа?

Распределение случайных чисел

Функции для работы со случайными числами

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