ЦИКЛ while ("до тех пор, пока истинно")
while(условие)
оператор;
...продолжение...
или
while(условие){
операторы;
...
}
...продолжение...
|
V
|
+------>--+
| |
| V
П | ---------------------
о | | проверить УСЛОВИЕ |-------> если ложно (нуль)
в A --------------------- |
т | | |
о | V |
р | если истинно (не нуль) |
и | | |
т | V |
ь | оператор V
| | |
| | |
+-----<---+ |
|
+-------<---------------------+
|
V
продолжение
Пример:
int x;
x = 10;
while(x > 0){
printf("x=%d\n", x);
x = x - 1;
}
printf("Конец.\n");
printf("x стало равно %d.\n", x); /* печатает 0 */
"Цикл" он потому, что его тело повторяется несколько раз.
Чтобы цикл окончился, оператор-тело цикла должен менять
какую-то переменную, от которой зависит истинность условия повторений.
ОПЕРАТОРЫ "И, ИЛИ, НЕ"
Условия могут быть сложными.
ЕСЛИ красный И вес < 10 ТО ...;
ЕСЛИ красный ИЛИ синий ТО ...;
ЕСЛИ НЕ красный ТО ...;
На языке Си такие условия записываются так:
if(условие1 && условие2) ...; /* "И" */
if(условие1 || условие2) ...; /* "ИЛИ" */
if(! условие1) ...; /* "НЕ" */
Например:
if(4 < x && x <= 12) ...;
Было бы неправильно записать
if(4 < x <= 12) ...;
ибо язык программирования Си НЕ ПОНИМАЕТ двойное сравнение!
Еще примеры:
if(x < 3 || y > 4) ...;
if( ! (x < 3 || y > 4)) ...;
ЦИКЛ for ("для каждого")
Этот цикл является просто иной записью одного из вариантов цикла while.
Он служит обычно для выполнения опеределенного действия несколько раз,
не "пока истинно условие", а "выполнить N-раз".
У такого цикла есть "переменная цикла" или "счетчик повторений".
int i;
i = a; /* начальная инициализация */
while(i < b){
тело_цикла;
i += c; /* увеличение счетчика */
}
...продолжение...
переписывается в виде
int i;
for(i=a; i < b; i += c)
тело_цикла;
тело_цикла будет выполнено для значений i
a
a+c
a+c+c
...
пока i < b
В простейшем случае
for(i=1; i <= N; i++)
printf("i=%d\n", i);
i означает "номер повторения".
Такой цикл служит для повторения СХОЖИХ действий НЕСКОЛЬКО раз
с разным значением параметра.
ОПЕРАТОР break ("вывалиться из цикла")
Оператор break заставляет прервать выполнение тела цикла
и сразу перейти к продолжению программы.
while(условие1){
операторы1;
if(условие2)
break; ------->----+
|
операторы2; |
} |
...продолжение...<--------<---------+
и
for(i=0; условие1; i++){
операторы1;
if(условие2)
break; ------->----+
|
операторы2; |
} |
...продолжение...<--------<---------+
Этот оператор позволяет организовывать дополнительные
точки выхода из цикла (при дополнительных условиях).
Пример:
for(i=0; i < 20; i++){
printf("i=%d\n", i);
if(i == 7){
printf("break loop!\n");
break; /* вывалиться из цикла */
}
printf("more\n");
}
printf("finished, i=%d\n", i); /* печатает 7 */
В частности, с его помощью можно организовывать бесконечный цикл:
for(;;){ /* заголовок бесконечного цикла */
операторы1;
if(условие2)
break; ------->----+
|
операторы2; |
} |
...продолжение...<--------<---------+
Здесь в самом заголовке цикла НЕ ПРОВЕРЯЕТСЯ НИКАКИХ УСЛОВИЙ,
такой цикл продолжается бесконечно.
Условие продолжения считается всегда истинным.
Единственный способ выйти из него -
это сделать break (при каком-то условии) в теле цикла, что и написано.
Бесконечный цикл можно также организовать при помощи
while(1){
...
}
ОПЕРАТОР ВЫВОДА (ПЕЧАТИ)
printf("текст");
Печатает на экран текст.
printf("текст\n");
Печатает на экран текст и переходит к новой строке.
printf("слово1 слово2 ");
printf("слово3\n");
печатает
слово1 слово2 слово3
и переходит на новую строку.
Если переход на новую строку не задан явно, символом \n,
то текст продолжает печататься в текущей строке.
printf("%d", x);
Печатает в текстовом виде ЗНАЧЕНИЕ переменной x.
Специальная конструкция %d означает
"взять переменную из списка после запятой
и напечатать ее значение в ивде целого числа".
printf("икс равен %d - ого-го\n", x);
Печатает сначала текст
икс равен
затем значение переменной x как целое число,
затем текст
- ого-го
и переходит на новую строку (поскольку указан символ \n).
Этот оператор может печатать и несколько значений переменных:
int x, y;
x = 12; y = 15;
printf("икс есть %d, игрек есть %d, все.\n", x, y);
~~~~~~
Данный оператор работает так.
Строка "икс есть %d, игрек есть %d\n" называется ФОРМАТОМ.
Компьютер читает формат слева направо и печатает текст
до тех пор, пока не встретит символ %d.
Курсор изображен символом _
икс есть _
Далее он берет ПЕРВУЮ переменную из списка ~~~~ и
печатает ее как целое число.
икс есть 12_
далее он снова печатает текст пока не встретит %d
икс есть 12, игрек есть _
Теперь он берет ВТОРУЮ переменную из списка и печатает ее:
икс есть 12, игрек есть 15_
Снова печатает текст, включая перевод строки \n.
Как только строка формата кончилась, оператор printf завершен.
икс есть 12, игрек есть 15, все.
_
Печатать можно не только значения переменных, но и значения арифметических
выражений:
printf("равно: %d\n", 12 + 3 * 5);
Контрольный вопрос, что печатается:
int x, y, z;
x = 13;
y = 23;
z = 34;
printf("x=%d xx=%d\nzzz=%d\n", x, y - 1, z * 2 + 1);
Тут в формате есть ДВА перевода строки,
поэтому будет напечатано:
x=13 xx=22
zzz=69
_
Заметьте, что перед тем как быть напечатанными,
выражения в списке после формата ВЫЧИСЛЯЮТСЯ.
Что напечатает
printf("x=%d\n y=%d\n", x, y);
x=13
y=23
_
Пробел перед y возник потому, что он СОДЕРЖИТСЯ
в строке формата после символа \n !!!
Будьте внимательны.
ФУНКЦИИ
Функцией называется фрагмент программы,
в который передаются ПАРАМЕТРЫ,
и который ВОЗВРАЩАЕТ значение (или ничего).
Прелесть функции в том, что ее можно выполнить много раз
из разных точек программы.
Функция состоит из
ОБЪЯВЛЕНИЯ - описания того, как она что-то вычисляет
Объявление бывает ровно одно.
ВЫЗОВОВ - с конкретными значениями параметров,
что именно она должна на этот раз вычислить.
Вызовов может быть сколько угодно.
Объявление простейшей функции выглядит так:
int func(int x){
/* Один или несколько операторов,
завершающихся оператором return(нечто);
*/
return x+1;
}
---------------------------------------------------------------------------
int func(...
задает функцию с именем func
(имя выдумывает программист, как и имена переменных).
int означает, что функция возвращает целое значение.
---------------------------------------------------------------------------
...(int x)...
задает список аргументов (или параметров) функции.
---------------------------------------------------------------------------
...){
...
}
задает тело функции - некую последовательность объявлений
переменных и операторов.
---------------------------------------------------------------------------
return выражение;
задает оператор выхода из функции в точку ее вызова с возвратом значения
выражения.
---------------------------------------------------------------------------
Покажем простой пример ВЫЗОВА этой функции:
int y;
...
y = func(5); /* a */
...продолжение... /* b */
Этот фрагмент работает следующим образом:
y = func(5);
В этой точке мы
1) "записываем на бумажке",
что вызов произошел в такой-то строке, таком-то месте
нашей программы.
2) Смотрим на ОПРЕДЕЛЕНИЕ функции func.
int func(int x){...
Мы вызвали функцию как func(5).
Это значит, что в теле функции x получает начальное значение 5.
То есть ДЛЯ ДАННОГО ВЫЗОВА наша функция (ее тело) превращается в
int x;
x = 5;
return x+1;
3) x+1 есть 6.
Далее должен выполниться оператор return.
Он выполняется так:
Мы "читаем с бумажки" - откуда была вызвана функция func,
и смотрим на это место. Это было
y = func(5);
Вычеркиваем func(5) и заменяем его ЗНАЧЕНИЕМ выражения,
вычисленного в операторе return;
y = 6;
4) Выполняем этот оператор и переходим к продолжению.
---------------------------------------------------------------------------
int y, z, w;
y = func(5);
z = func(6);
w = func(7) + func(8) + 1;
Превратится в
y = 6;
z = 7;
w = 8 + 9 + 1;
При этом мы четыре раза "прыгнем" на определение функции func(),
пройдем все ее операторы с разными значениями параметра x
и вернемся обратно в точку вызова.
ПРОГРАММА В ЦЕЛОМ
Программа в целом состоит из функций.
Одна из функций должна иметь имя main(),
С ФУНКЦИИ main НАЧИНАЕТСЯ ВЫПОЛНЕНИЕ ПРОГРАММЫ.
(на самом деле этому предшествует отведение и инициализация
глобальных переменных; смотри последующие лекции).
Часто main() - единственная функция в программе.
---------------------------------------------------------------------------
Структура программы такова:
#include /* магическая строка */
/* ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ (о них позже) */
int a = 7;
int b; /* по умолчанию 0 */
/* ФУНКЦИИ */
f1(){....}
f2(){....}
/* НАЧАЛЬНАЯ (ГЛАВНАЯ) ФУНКЦИЯ */
void main(){
...
}
---------------------------------------------------------------------------
