Андрей Богатырев. Руководство полного идиота
по программированию (на языке Си)
С Copyright Андрей Богатырев
Email: abs@opentech.olvit.ru
---------------------------------------------------------------------------
ПЕРЕМЕННЫЕ
Переменная - это такой "ящичек" с именем,
в котором может храниться некое ЗНАЧЕНИЕ.
Имя у переменной постоянно и неизменно,
значение же может меняться.
Например, пусть у нас есть переменная с именем "x".
-----
/ x /
---------------
| Текущее |
| значение, |
| например 12 |
---------------
Переменную можно изменять при помощи операции ПРИСВАИВАНИЯ.
В языке Си она обозначается знаком равенства.
x = 12 ;
Это читается не как "икс равно 12",
а как "присвоить переменной икс значение 12",
то есть "Положить в ящик с надписью ИКС число 12".
Такая строка является простейшим ОПЕРАТОРОМ,
то есть ДЕЙСТВИЕМ. В конце операторов ставится точка с запятой.
Рассмотрим оператор
x = x + 3;
Это не уравнение. Если рассматривать эту строку как математическое
уравнение, оно не имеет решений. На самом деле тут написано:
1) "взять значение переменной ИКС"
2) "прибавить к нему 3"
3) "положить новое значение в переменную ИКС",
стерев в ней прежнее значение.
У опреатора присваивания есть две части: ЛЕВАЯ и ПРАВАЯ.
ЛЕВАЯ_ЧАСТЬ = ПРАВАЯ_ЧАСТЬ ;
В левой части обычно стоит просто имя переменной В КОТОРУЮ
записывается вычисленный справа результат.
Если имя переменной встречается в ПРАВОЙ части, то это
означает "подставить сюда текущее значение этой переменной".
При этом текущее значение самой переменной НЕ изменяется,
берется его копия. То есть, "вынутое из ящика значение"
не оставляет ящик пустым! Вынимается копия, другая копия остается в ящике.
Итак:
x = x + 3 ;
Пусть сейчас значение x есть 12
Сначала вычисляется ПРАВАЯ часть оператора присваивания.
x + 3
-----
/ x /
---------------
| 12 | |
--------|------
|
|
| ВЗЯТЬ копию значения (то есть число 12) из ящика с именем "ИКС"
|
V
Вместо x
подставляем
число
12 + 3 ----> СКЛАДЫВАЕМ.
Сложение дает 15.
В этот момент x все еще равно 12
(в ящике лежит число 12)
Теперь вычисляется само присваивание:
x = 15 ;
|
|
| ПОЛОЖИТЬ результат в ящик с именем "ИКС"
| (истребив в нем прежнее значение, если было)
-----|
/ x / |
--------|------
| 12 V |
---------------
Стало:
-----
/ x /
---------------
| 15 |
---------------
В переменной с тем же именем теперь находится новое значение,
она изменилась. Потому и "переменная".
В некоторых языках программирования, например в Pascal или Modula,
операция присваивания обозначается символом := а не =
Это уменьшает путаницу, но к смыслу = можно привыкнуть довольно быстро.
Не огорчайтесь.
В правой части значение переменной может использоваться несколько раз:
z = x * x + 2 * x;
Тут есть две переменные:
z - для результата.
x - уже имеющая какое-то значение.
x * x означает "умножить икс на икс" (при этом само значение,
лежащее в ящике икс не изменяется!)
x * 2 означает "взять два значения икс"
+ означает сложение.
Переменные надо ОБЪЯВЛЯТЬ.
Это необходимо потому, что иначе, если бы переменные вводились просто
использованием имени переменной, и мы вдруг допустили бы ОПЕЧАТКУ, например:
иднекс = 1;
вместо
индекс = 1;
то у нас появилась бы "лишняя" переменная "иднекс", а ожидаемое действие не
произошло бы. Такую ошибку найти черезвычайно тяжело. Если же переменные
надо объявлять, то необъявленные переменные будут выявлены еще на стадии
компиляции программы.
Переменные, которые будут хранить целые числа ( ..., -2, -1, 0, 1, 2, 3, ...),
объявляют так:
int переменная1;
int переменная2;
Или сразу несколько в одной строке:
int переменная1, переменная2;
int означает сокращение от слова integer - "целый".
ПРОГРАММА
Программа состоит из ОПЕРАТОРОВ, то есть действий.
Операторы выполняются последовательно в том порядке,
в котором они записаны.
/* ОБЪЯВЛЯЕМ ДВЕ ПЕРЕМЕННЫЕ */
int x, y; /* 0 */
/* Это еще не операторы, хотя при этом создаются 2 ящика для
целых чисел
*/
/* А ТЕПЕРЬ - ОПЕРАТОРЫ. */
/* Мы начнем с простых операторов присваивания и арифметики */
x = 3; /* 1 */
y = 4; /* 2 */
x = x + y; /* 3 */
y = y - 1; /* 4 */
x = y; /* 5 */
Значения переменных (то, что лежит в ящиках) меняются таким образом:
x y
/* 0 */ мусор мусор
/* после 1 */ 3 мусор
/* после 2 */ 3 4
/* после 3 */ 7 4
/* после 4 */ 7 3
/* после 5 */ 3 3
Как вы видите, переменные, которые не участвуют в левой части оператора
присваивания, этим оператором НЕ МЕНЯЮТСЯ.
Последняя операция x = y; НЕ делает имена x и y синонимами.
Такой вещи, как "перевешивание табличек с именами с ящика на ящик"
не происходит. Вместо этого, два ящика с именами x и y содержат
одинаковые значения, то есть две копии одного и того же числа.
----- -----
/ x / / y /
--------------- ---------------
| 3 *<--|--------<----|-- 3 |
--------------- 1) ---------------
2), 3) 4)
1) Из ящика y берется КОПИЯ числа 3 (безымянное значение).
2) Старое содержимое ящика x уничтожается.
3) Число 3 кладется в ящик x.
4) В исходном ящике y попрежнему осталось 3.
Значение целой переменной можно вывести на экран оператором печати:
printf("%d\n", x);
Пока будем рассматривать его как "магический".
Над целыми числами можно производить такие арифметические операции:
x + y сложение
x - y вычитание
x * y умножение
x / y деление нацело (то есть с остатком; результат - целое)
x % y вычислить остаток от деления нацело
5 / 2 даст 2
5 % 2 даст 1
В операторах присваивания используются такие сокращения:
ДЛИННАЯ ЗАПИСЬ СМЫСЛ СОКРАЩАЕТСЯ ДО
x = x + 1; "увеличить на 1" x++; (или ++x; )
x = x - 1; "уменьшить на 1" x--; (или --x; )
x = x + y; "прибавить y" x += y;
x = x * y; "умножить на y" x *= y;
x = x / y; "поделить на y" x /= y;
В том числе x++; можно записать как x += 1;
* СТРУКТУРЫ УПРАВЛЕНИЯ *
Обычно операторы выполняются последовательно,
в том порядке, в котором они записаны в программе.
оператор1; |
оператор2; |
оператор3; |
оператор4; V
УСЛОВНЫЙ ОПЕРАТОР
if(условие) оператор;
...продолжение...
Работает так:
Вычисляется условие.
Если оно истинно, то выполняется оператор,
затем выполняется продолжение.
Если оно ложно, то сразу выполняется продолжение,
а оператор не выполняется.
Если нам надо выполнить при истинности условия несколько операторов,
мы должны заключить их в скобки { ... } - это так называемый
"составной оператор".
if(условие) {
оператор1;
оператор2;
...
}
продолжение
После } точка с запятой НЕ СТАВИТСЯ (можно и поставить, но не нужно).
Условный оператор изображают на схемах так:
|
|
|
----------------
---| ЕСЛИ условие |----
| ---------------- |
| |
V V
истинно ложно
| |
V |
------------ |
| оператор | |
------------ |
| |
------->-------<-------
|
|
V
продолжение
|
Имеется вторая форма, с частью "иначе":
if(условие) оператор_если_истинно;
else оператор_если_ложно;
"или то, или другое" (но не оба сразу)
|
|
|
----------------
---| ЕСЛИ условие |-----------
| ---------------- |
| |
V V
истинно ложно
| |
V |
------------------------- -----------------------
| оператор_если_истинно | | оператор_если_ложно |
------------------------- -----------------------
| |
------->-------<--------------
|
|
V
продолжение
|
Пример1:
if(x > 10)
printf("Икс больше десяти\n");
Пример2:
int x, y, z;
if(x < y) z = 1;
else z = 2;
Условия:
В качестве условий могут использоваться операторы СРАВНЕНИЯ
(сравнивать можно переменные, выражения, константы)
x < y меньше
x > y больше
x <= y меньше или равно
x >= y больше или равно
x == y равно
x != y не равно
Все эти операторы в качестве результата операции сравнения выдают
1, если сравнение истинно
0, если оно ложно.
Таким образом, на самом деле условный оператор работает так:
if(условие) ....
Если условие есть НОЛЬ - то условие считается ложным.
Если условие есть НЕ НОЛЬ а ... -2, -1, 1, 2, 3, ... - то условие истинно.
Это определение.
Из него в частности вытекает, что сравнение с целым нулем можно опускать:
if(x != 0) ... ; сокращается до if(x) ... ;
if(x == 0) ... ; сокращается до if(!x) ... ;
---------------------------------------------------------------------------
Пример:
int x, y, z;
if(x == 1){ y = 2; z = x + y; }
else { y = 1; z = x - y; }
---------------------------------------------------------------------------
Пример со вложенными условными операторами:
if(x == 1){
printf("Икс равен 1\n");
if(y == 2){
printf("Игрек равен 2\n");
}
} else {
printf("Икс не равен 1\n");
}
---------------------------------------------------------------------------
Часто применяется последовательность условных операторов,
перебирающая различные варианты:
if(x == 1)
printf("Икс равен 1\n");
else if(x == 2)
printf("Икс равен 2\n");
else if(x == 3){
printf("Икс равен 3\n");
y = 1;
} else
printf("Непредусмотренное значение икс\n");
---------------------------------------------------------------------------
Самое сложное - привыкнуть к тому, что сравнение обозначается знаком ==,
а не =
Знак = означает "присвоить значение", а не "сравнить на равенство".
