Как не надо программировать циклы

ПЕРЕМЕННЫЕ

Переменная — это такой ящичек с именем,в котором может храниться некое ЗНАЧЕНИЕ.Имя у переменной постоянно и неизменно,значение же может меняться. Например, пусть у нас есть переменная с именем 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 ** СТРУКТУРЫ УПРАВЛЕНИЯ *Обычно операторы выполняются последовательно,в том порядке, в котором они записаны в программе. оператор1; | оператор2; | оператор3; | оператор4; V

УСЛОВНЫЙ ОПЕРАТОР

if(условие) оператор; …продолжение… Работает так: Вычисляется условие. Если оно истинно, то выполняется оператор, затем выполняется продолжение. Если оно ложно, то сразу выполняется продолжение, а оператор не выполняется. Если нам надо выполнить при истинности условия несколько операторов,мы должны заключить их в скобки { … } — это так называемыйсоставной оператор. if(условие) { оператор1; оператор2; … } продолжение После } точка с запятой НЕ СТАВИТСЯ (можно и поставить, но не нужно). Условный оператор изображают на схемах так: | | | —————- —| ЕСЛИ условие |—- | —————- | | | V V истинно ложно | | V |———— || оператор | |———— | | | ——————— 10) printf(Икс больше десяти\n); Пример2: int x, y, z; if(xy) z = 1; else z = 2; Условия: В качестве условий могут использоваться операторы СРАВНЕНИЯ (сравнивать можно переменные, выражения, константы) xy больше 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);————————————————————————-Самое сложное — привыкнуть к тому, что сравнение обозначается знаком ==,а не =Знак = означает присвоить значение, а не сравнить на равенство.

ЦИКЛ while (до тех пор, пока истинно)

while(условие) оператор; …продолжение… или while(условие){ операторы; … } …продолжение… | V | +———+ | | | V П | ——————— о | | проверить УСЛОВИЕ |——- если ложно (нуль) в A ——————— | т | | | о | V | р | если истинно (не нуль) | и | | | т | V | ь | оператор V | | | | | | +——ОПЕРАТОРЫ И, ИЛИ, НЕУсловия могут быть сложными. ЕСЛИ красный И вес10 ТО …; ЕСЛИ красный ИЛИ синий ТО …; ЕСЛИ НЕ красный ТО …; На языке Си такие условия записываются так: if(условие1условие2) …; /* И */ if(условие1 || условие2) …; /* ИЛИ */ if(! условие1) …; /* НЕ */ Например: if(4xx ЦИКЛ for (для каждого)Этот цикл является просто иной записью одного из вариантов цикла while.Он служит обычно для выполнения опеределенного действия несколько раз,не пока истинно условие, а выполнить N-раз. У такого цикла есть переменная цикла или счетчик повторений. int i; i = a; /* начальная инициализация */ while(ib){ тело_цикла; i += c; /* увеличение счетчика */ } …продолжение… переписывается в виде int i; for(i=a; ib; i += c) тело_цикла; тело_цикла будет выполнено для значений i a a+c a+c+c … пока ib В простейшем случае for(i=1; i ОПЕРАТОР break (вывалиться из цикла)Оператор break заставляет прервать выполнение тела циклаи сразу перейти к продолжению программы. while(условие1){ операторы1; if(условие2) break; ————+ | операторы2; | } | …продолжение…ОПЕРАТОР ВЫВОДА (ПЕЧАТИ) 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(){ … }————————————————————————-Пример программы: #includeint f1(int x, int y){ return (x + y*2);} int f2(int x){ int z; z = x+7; return 2*z;} void main(){ /* Объявления переменных */ int a, b, c; /* Операторы */ a = 5; b = 6; c = f1(a, b+3); b = f1(1, 2); a = f2(c); printf(A есть %d B есть %d C есть %d\n, a, b, c);} Она печатает: A есть 60 B есть 5 C есть 23

КАК НЕ НАДО ПРОГРАММИРОВАТЬ ЦИКЛЫ

int i; for(i=0; i4; i++){ if(i == 0) func0(); else if(i == 1) func1(); else if(i == 2) func2(); else if(i == 3) func3(); } В данном примере цикл АБСОЛЮТНО НЕ НУЖЕН.То, что тут делается, есть просто ПОСЛЕДОВАТЕЛЬНОСТЬ операторов: func0(); func1(); func2(); func3(); Цикл имеет смысл лишь тогда, когда много раз вызываетсяОДНО И ТО ЖЕ действие, но может быть зависящее от параметра, вроде func(i).Но не разные функции для разных i. Аналогично, рассмотрим такой пример: int i; for(i=0; i10; i++){ if(i==0) func0(); else if(i == 1) func1(); else if(i == 2) func2(); else funcN(i); } Тут funcN(i) берет на себя роль а в остальных случаях.Однако, этот пример более естественно может быть записан так: int i; func0(); func1(); func2(); for(i = 3; i10; i++) funcN(i); Заметьте, что цикл теперь начинается с индекса 3. А теперь — случай, где смесь цикла и условного оператора оправдана: int i; for(i=0; i100; i++){ if((i % 2) == 0) even(); /* четный */ else odd(); /* нечетный */ } Тут в цикле проверяется четность индекса i.

/* Треугольник из звездочек */ #include/* putchar(‘c’) — печатает одинокий символ c *//* символ \n — переводит строку *//* nstars — сколько звездочек напечатать */ /* Функция рисования одной строки треугольника */void drawOneLine(int nstars){ int i; /* номер печатаемой звездочки, счетчик */ for(i=0; instars; i++) /* Рисуем nstars звездочек подряд */ putchar(‘*’); putchar(‘\n’); /* И переходим на следующую строку */} void main(){ /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */ int nline; /* номер строки */ /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */ for(nline=1; nline

/* Треугольник из звездочек *//* Тот же пример со вложенным циклом, а не с функцией */ #includevoid main(){ /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */ int nline; /* номер строки */ int i; /* номер печатаемой звездочки, счетчик */ /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */ for(nline=1; nline

/* Треугольник из звездочек *//* Теперь треугольник должен быть равнобедренным */ #include/* nstars — сколько звездочек напечатать *//* nspaces — сколько пробелов напечатать перед звездочками */ void drawOneLine(int nspaces, int nstars){ int i; /* номер печатаемой звездочки, счетчик */ /* он же — номер печатаемого пробела */ for(i=0; inspaces; i++) putchar(‘ ‘); for(i=0; instars; i++) putchar(‘*’); putchar(‘\n’);} /* n (номер строки) …* 1 ..*** 2 .***** 3 ******* 4 Всего строк: LINES Число звездочек в n-ой строке: n*2 — 1 Число пробелов спереди (обозначены точкой): LINES — n Все эти числа подсчитываются с картинки… Их мы будем передавать в функцию drawOneLine в точке _вызова_, а не вычислять в самой функции. Функция для того и заведена, чтобы не вычислять ничего КОНКРЕТНОГО — все параметры ее переменные, и должны ПЕРЕДАВАТЬСЯ в нее из точки вызова. В качестве параметра в точке вызова можно передавать не только значение переменной, но и значение выражения, то есть формулы. */void main(){ /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */ int LINES = 25; /* всего строк. Это описание переменной сразу с ее инициализацией */ int nline; /* номер строки */ /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */ for(nline=1; nlinenspaces */ nline*2 — 1 /* число звездочек — nstars */ );}

/* Треугольник из звездочек *//* Теперь треугольник должен быть равнобедренным */ #includevoid drawOneLine(int nspaces, int nstars){ int i; /* номер печатаемой звездочки, счетчик */ /* он же — номер печатаемого пробела */ for(i=0; inspaces; i++) putchar(‘ ‘); for(i=0; instars; i++) putchar(‘*’); putchar(‘\n’);} void main(){ /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */ int LINES = 25; /* всего строк. */ int nline; /* номер строки */ /* Для человека естественно считать с 1. Для машины же первое число — это НУЛЬ. Поэтому цикл for(nline=1; nline

/* Тип переменных для хранения БУКВ называется char (от слова character). Буквы изображаются в одиночных кавычках ‘a’ ‘b’ ‘+’. Пример: char letter; letter = ‘a’; putchar(letter); letter = ‘b’; putchar(letter); letter = ‘\n’; putchar(letter); Символ ‘\n’ обозначает невидимую букву — переход на новую строку, new line. Есть несколько таких специальных букв, о них — позже. Зато сразу сделаем оговорку. Чтобы изобразить саму букву \ следует использовать ‘\\’ putchar(‘\’); или printf (\); ошибочны. Надо: putchar(‘\\’); printf(\\); Дело в том, что символ \ начинает последовательность из ДВУХ букв, изображающих ОДНУ букву, иногда вызывающую специальные действия на экране или на принтере.*/ /* Число делится на n, если ОСТАТОК от деления его на n равен 0, то есть если (x % n) == 0 В частности, так можно проверять числа на четность/нечетность, беря x%2. Остатки от деления числа x на n это 0 1 2 … n-1. В случае деления на 2 остаток 0 соответствует четному x 1 соответствует нечетному x */ /* Задача: Нарисовать треугольник из звездочек в нечетных строках из плюсиков в четных строках *———————————————————* Решение: используем прежнюю программу, добавив в функцию drawOneLine еще один аргумент — symbol — каким символом рисовать строку. Далее в основном цикле используем условный оператор и проверку номера строки на четность. */ #includevoid drawOneLine(int nspaces, int nsymbols, char symbol){ int i; /* счетчик */ for(i=0; inspaces; i++) putchar(‘ ‘); for(i=0; insymbols; i++) putchar(symbol); putchar(‘\n’);} /* Мы вынесем объявление этой переменной из функции, сделав ее глобальной, то есть видимой во ВСЕХ функциях. */int LINES = 25; /* всего строк. */ void main(){ /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */ int nline; /* номер строки */ /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */ for(nline=0; nlineLINES; nline++){ if((nline % 2) == 0) /* четное ? */ drawOneLine(LINES — nline — 1, nline*2 + 1, ‘+’); else drawOneLine(LINES — nline — 1, nline*2 + 1, ‘*’); }}

/* То же самое, но теперь нужно еще и печатать номер строки. */ #include/* Вообще-то глобальные переменные принято объявлять в самом начале файла с программой. */ int LINES = 25; /* всего строк. */ /* Добавим к функции еще один аргумент, указатель — печатать ли номер строки. Назовем его drawLineNumber. Не впадите в заблуждение по аналогии с именем ФУНКЦИИ drawOneLine() ! В данном случае — это имя ПЕРЕМЕННОЙ — АРГУМЕНТА ФУНКЦИИ. Оператор if(x) …..; РАБОТАЕТ ТАКИМ ОБРАЗОМ (так он устроен): в качестве условия он принимает целое число (типа int). Условие истинно, если x != 0, и ложно, если x == 0. Второй добавленный аргумент — собственно номер строки.*/void drawOneLine(int nspaces, int nsymbols, char symbol, /* а это мы добавили */ int drawLineNumber, int linenum){ int i; /* счетчик */ if(drawLineNumber) printf(%d\t, linenum); /* без перевода строки */ /* На самом деле это условие более полно надо записывать как if(drawLineNumber != 0) но в языке Си это то же самое. */ /* Тут мы снова видим новый специальный символ \t — ТАБУЛЯЦИЯ. Весь экран (или лист бумаги) условно поделен на колонки шириной по 8 позиций. Примерно так:| | | | | | | | | … Символ табуляции вызывает переход из текущей позиции в начало следующей колонки. Например| | | | | | | | | … ^ отсюда | | | | | | | | | … ^ в это место */ for(i=0; inspaces; i++) putchar(‘ ‘); for(i=0; insymbols; i++) putchar(symbol); putchar(‘\n’);} void main(){ /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */ int nline; /* номер строки */ /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */ for(nline=0; nlineLINES; nline++){ if((nline % 2) == 0) /* четное ? */ drawOneLine(LINES — nline — 1, nline*2 + 1, ‘+’, 1, nline); else drawOneLine(LINES — nline — 1, nline*2 + 1, ‘*’, 9, nline); } /* А почему именно 1 или именно 9 ? * А все что попало, лишь бы не 0. * Можно 3, 333, 666, -13445, итп * * Вопрос: что будет, если тут написать 0 ? */}

/* Следующая задача будет касаться того, чтобы каждая строка треугольника печаталась в виде: *+*+*+*…..*+* Тут нам уже придется модифицировать функцию рисования строки.*/ #includeint LINES = 25; /* всего строк. */ void drawOneLine(int nspaces, int nsymbols){ int i; for(i=0; inspaces; i++) putchar(‘ ‘); /* в цикле мы будем проверять на четность НОМЕР печатаемого символа. */ for(i=0; insymbols; i++){ if((i % 2) == 0) putchar(‘*’); else putchar(‘+’); } putchar(‘\n’);} void main(){ int nline; /* номер строки */ for(nline=0; nlineLINES; nline++) { drawOneLine(LINES — nline — 1, nline*2 + 1); }}

/* Задача нарисовать РОМБ: * *** ***** *** **/ #includeint LINES = 10; /* всего строк в половине ромба. */ void drawOneLine(int nspaces, int nsymbols){ int i; for(i=0; inspaces; i++) putchar(‘ ‘); for(i=0; insymbols; i++) putchar(‘+’); putchar(‘\n’);} void main(){ int nline; /* номер строки */ for(nline=0; nline = 0; nline—) drawOneLine(LINES — nline — 1, nline*2 + 1);}

/* А теперь рисуем ромб, используя математические формулы. */ #includevoid draw(int nspaces, int nstars, char symbol){ int i; for(i=0; inspaces; i++) putchar(‘ ‘); for(i=0; instars; i++) putchar(symbol); putchar(‘\n’);} void main(){ int LINES = 21; int MIDDLELINE = LINES/2 + 1; /* середина ромба */ int nline; for(nline=0; nlineMIDDLELINE; nline++) draw(MIDDLELINE — nline -1, nline*2+1, ‘A’); /* У следующего цикла for() нет инициализации начального значения индекса. Начальное nline наследуется из предыдущего цикла, таким, каким оно осталось после его окончания, то есть равным MIDDLELINE. */ for( ; nlineLINES; nline++) draw(nline — MIDDLELINE + 1, (LINES — 1 — nline) * 2 + 1, ‘V’);}

* 12_ARRAYS.txt *

МАССИВЫ

Массив — это несколько пронумерованных переменных, объединенных общим именем. Все переменные имеют ОДИН И ТОТ ЖЕ ТИП. Рассмотрим ПОЛКУ с N ящиками,пусть имя полки — var.Тогда кажждый ящик-ячейка имеет имя var[0] var[1] … var[N-1] Нумерация идет с НУЛЯ. ——— / var / / / ——————————————- —————— | | | | | | | | | | …. … | | | | | | | | ——————————————- —————— / var[0] / / var[1] / / var[2] / / var[N-1] / ——— ——— ——— ———— Массив объявляется так: int var[N]; здесь N — его размер, число ячеек. Это описание как бы объявляет N переменных типа int с именами var[0] … var[N-1]; В операторах для обращения к n-ому ящичку (где 0 СТРОКИ Строки есть массивы БУКВ — типа char,оканчивающиеся спецсимволом \0 char string[20]; string[0] = ‘П’; string[1] = ‘р’; string[2] = ‘и’; string[3] = ‘в’; string[4] = ‘е’; string[5] = ‘т’; string[6] = ‘\0’; printf(%s\n, string); %s — формат для печати СТРОК.Никакие другие массивы не могут быть напечатаныцеликом одним оператором. char string[20]; string[0] = ‘П’; string[1] = ‘р’; string[2] = ‘и’; string[3] = ‘в’; string[4] = ‘е’; string[5] = ‘т’; string[6] = ‘\n’; /* Перевод строки — тоже буква */ string[7] = ‘\0’; printf(%s, string); или даже просто printf(string); Такие массивы можно записать в виде строки букв вchar string[20] = Привет\n; Оставшиеся неиспользованными символы массива от string[8] до string[19]содержат МУСОР. ПОЧЕМУ ДЛЯ СТРОК ИЗОБРЕЛИ СИМВОЛ ПРИЗНАК КОНЦА?=================================================Строка — это ЧАСТЬ массива букв.В разное время число букв в строке может быть различным,лишь бы не превышало размер массива (тогда случится сбой программы).Значит, следует где-то хранить текущую длину строки (число использованныхсимволов). Есть три решения:(1) В отдельной переменной. Ее следует передавать во все функции обработки данной строки (причем она может изменяться). char str[32]; /* массив для строки */ int slen; /* брать первые slen букв в этом массиве */ … func(str, slen); /* ДВА аргумента для передачи ОДНОЙ строки */ … Этот подход работоспособен, но строка разбивается на два объекта: сам массив и переменную для его длины. Неудобно. (2) Хранить текущую длину в элементе str[0], а буквы — в str[1] … итд. Плохо тем, что в str[0] можно хранить лишь числа от 0 до 255, и если строка длиннее — то такой подход неприменим. (3) Не хранить длину НИГДЕ, а ввести символ-признак конца строки. Теперь в func(str); /* ОДИН аргумент — сам массив */ передается только сам массив, а его текущая длина может быть при нужде вычислена при помощи некоей функции, вроде такой: int strlen(char s[]){ /* функция от массива букв */ int counter = 0; /* счетчик и одновременно индекс */ while(s[counter] != ‘\0’) /* пока не встретился признак конца текста */ counter++; /* посчитать символ */ return counter; /* сколько символов, отличных от ‘\0’ */} Тут никаких ограничений нет. Именно этот подход и был избран в языке Си, хотя в принципе можно самому пользоваться и другими. На самом деле в языке есть такая СТАНДАРТНАЯ функция strlen(s) (вам не надо писать ее самому, ее уже написали за вас).———————————————————————ИНИЦИАЛИЗАЦИЯ ГЛОБАЛЬНОГО МАССИВА=================================Массив, заданный вне каких-либо функций, можно проинициализироватьконстантными начальными значениями: int array[5] = { 12, 23, 34, 45, 56 }; char string[7] = { ‘П’, ‘р’, ‘и’, ‘в’, ‘е’, ‘т’, ‘\0’ }; Если размер массива указан БОЛЬШЕ, чем мы перечислим элементов,то остальные элементы заполнятся нулями (для int) или ‘\0’ для char. int array[5] = { 12, 23, 34 }; Если мы перечислим больше элементов, чем позволяет размер массива -это будет ошибкой. int a[5] = { 177, 255, 133 }; Операция индексации массива a[] дает: при n значение выражения a[n] есть———————————————1 не определено (ошибка: индекс за границей массива)0 1771 2552 1333 04 05 не определено (ошибка)

* 13_FUNCS.txt *

КАК ПРОИСХОДИТ ВЫЗОВ ФУНКЦИИ============================ Пусть у нас описана функция, возвращающая целое значение. /* ОПРЕДЕЛЕНИЕ ФУНКЦИИ func(). */ /* Где func — ее имя. Назвать мы ее можем как нам угодно. */ int func(int a, int b, int c){ int x, y; … x = a + 7; … b = b + 4; … return(некое_значение); } Здесь a, b, c — аргументы функции (параметры) x, y — локальные переменные Точка вызова — находится внутри какой-то другойфункции, например функции main() main(){ int zz, var; … var = 17; zz = func(33, 77, var + 3) + 44; …} Когда выполнение программы доходит до строки zz = func(33, 77, var + 3) + 44; 1) Происходит ВЫЗОВ ФУНКЦИИ func() (a) Этот пункт мы увидим ниже. (b) Создаются переменные с именами a, b, c, x, y; (c) Переменным-аргументам присваиваются начальные значения, которые берутся из точки вызова. В точке вызова перечислен список (через запятую) выражений (формул): func(выражение1, выражение2, выражение3) Вычисленные значения этих выражений соответственно будут присвоены 1-ому, 2-ому и 3-ему аргументам (параметрам) из определения функции: int func(a, b, c){ /* a = номер 1, b = 2, c = 3 */ Первый параметр: a = 33; Второй параметр: b = 77; Третий параметр: c = var + 3; то есть, вычисляя, c = 20; Локальные переменные x и y содержат неопределенные значения, то есть мусор (мы не можем предсказать их значения, пока не присвоим им явным образом какое-либо значение сами). 2) Выполняется ТЕЛО функции, то есть вычисления, записанные внутри { … } в определении функции. Например: x = a + 7; И параметры, и локальные переменные — это ПЕРЕМЕННЫЕ, то есть их можно изменять. b = b + 4; При этом никакие переменные ВНЕ этой функции не изменяются. (Об этом еще раз позже). 3) Производится ВОЗВРАТ из функции. … return(некое_значение); } Например, это может быть … return(a + 2 * x); } Рассмотрим, что при этом происходит в точке вызова: zz = func(33, 77, var + 3) + 44; (1) Вычеркиваем func(…..) zz = XXXXXXX + 44; (2) Вычисляем значение некое_значение в операторе return, и берем КОПИЮ этого значения. Пусть при вычислении там получилось 128. (3) Подставляем это значение на место вычеркнутого func(…..) У нас получается zz = 128 + 44; (4) АВТОМАТИЧЕСКИ УНИЧТОЖАЮТСЯ локальные переменные и аргументы функции: a — убито b — убито c — убито x — убито y — убито Таких переменных (и их значений) больше нет в природе. (5) Пункт, который мы обсудим позже. (6) Продолжаем вычисление: zz = 128 + 44; Вычисляется в zz = 172; /* оператор присваивания */ ————————————————————————- int func1(int x){ printf(func1: x=%d\n, x); /* 1 */ x = 77; printf(func1: x=%d\n, x); /* 2 */ return x;} void main(){ int var, y; var = 111; y = func1(var); /* @ */ printf(main: var=%d\n, var); /* 3 */} В данном случае в точке @ мы передаем в функцию func1()ЗНАЧЕНИЕ переменной var, равное 111.Это значит, что при вызове функции будет создана переменная xи ей будет присвоено начальное значение 111 x = 111; Поэтому первый оператор printf() напечатает 111. Затем мы изменяем значение переменной x на 77.Мы меняем переменную x, но не переменную var !!!Использовав ЗНАЧЕНИЕ (его копию) из переменной var для x,мы о переменной var забыли — она нас не касается (а мы — ее). Поэтому второй оператор printf() напечатает 77.В переменной же var осталось значение 111,что и подтвердит нам третий оператор printf,который напечатает 111. ————————————————————————-ВРЕМЕННОЕ СОКРЫТИЕ ПЕРЕМЕННЫХ============================= int func1(int x){ /* f.1 */ printf(func1: x=%d\n, x); /* f.2 */ x = 77; /* f.3 */ printf(func1: x=%d\n, x); /* f.4 */ return x; /* f.5 */} void main(){ int x, y; /* 1 */ x = 111; /* 2 */ y = func1(x); /* 3 */ printf(main: x=%d y=%d\n, x, y); /* 4 */} А теперь мы и переменную внутри main(), и аргумент функцииfunc1() назвали одним и тем же именем. Что будет? Будет то же самое, что в предыдущем примере. В момент вызова функции func1() будет создана НОВАЯ переменнаяс именем x, а старая (прежняя) переменная и ее значение будутВРЕМЕННО СПРЯТАНЫ (скрыты). Можно было бы уточнить эти переменные именами функций,в которых они определены: main::x и func1::x (но это уже конструкции из языка Си++, а не Си). Выполним программу по операторам: |/* 1 */ Отводятся переменные main::x и main::y для целых чисел;|/* 2 */ main::x = 111;|/* 3 */ Вызывается func1(111);|+——-+. |/* f.1 */ Отводится переменная func1::x со значением 111;. |/* f.2 */ Печатается 111 из переменной func1::x;. |. |/* f.3 */ func1::x = 77; (это не main::x, а другая переменная,. | ЛОКАЛЬНАЯ для функции func1.. | Переменную main::x мы сейчас не видим -. | она заслонена именем нашей локальной. | переменной.. | Поэтому мы не можем ее изменить).. |. |/* f.4 */ Печатает 77 из func1::x;. |/* f.5 */ Возвращает значение func1::x , то есть 77.. | Переменная func1::x уничтожается.. |. | Теперь мы снова возвращаемся в функцию main(),. | где имя x обозначает переменную main::x. | а не func1::x+——-+||/* 3 */ y = 77;|/* 4 */ Печатает значения main::x и main::y, то есть| 111 и 77. Этот механизм сокрытия имен позволяет писать функции main() и func1()разным программистам, позволяя им НЕ ЗАБОТИТЬСЯ о том, чтобы именалокальных переменных в функциях НЕ СОВПАДАЛИ. Пусть совпадают — хуже небудет, механизм упрятывания имен разрешит конфликт.Зато программист может использовать любое понравившееся ему имяв любой функции — хотя бы и x, или i. ————————————————————————-То же самое происходит с локальными переменными,а не с аргументами функции. int func1(int arg){ /* локальная переменная-параметр func1::arg */ int x; /* локальная переменная func1::x */ x = arg; printf(func1: x=%d\n, x); x = 77; printf(func1: x=%d\n, x); return x;} void main(){ int x, y; /* переменные main::x и main::y */ x = 111; y = func1(x); printf(main: x=%d y=%d\n, x, y);} Действует тот же самый механизм временного сокрытия имени x.Вообще же, аргументы функции и ее локальные переменныеотличаются только одним: аргументам автоматически присваиваются начальные значения, равные значениям соответствующих выражений в списке имя_функции(…, …, ….) арг1 арг2 арг3 в месте вызова функции. То есть ОПИСАНИЕ ФУНКЦИИ: int f(int арг1, int арг2, int арг3){ int перем1, перем2; … /* продолжение */} ВЫЗОВ: …. f(выражение1, выражение2, выражение3) … ТО В ТЕЛЕ ФУНКЦИИ ВЫПОЛНИТСЯ (в момент ее вызова): арг1 = выражение1; арг2 = выражение2; арг3 = выражение3; перем1 = МУСОР; перем2 = МУСОР; … /* продолжение */ ————————————————————————-ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ===================== Наконец, существуют переменные, которые объявляются ВНЕ ВСЕХ ФУНКЦИЙ,и существующие все время выполнения программы(а не только то время, когда активна функция, в которой они созданы). Локальные переменные и аргументы УНИЧТОЖАЮТСЯ при выходеиз функции. Глобальные переменные — нет. int x = 12; /* ::x — ей можно заранее присвоить константу */int globvar; /* ::globvar */ int f1(){ int x; /* f1::x */ x = 77; printf(x=%d\n, x); /* 4 */ return x;} int f2(){ printf(x=%d\n, x); /* 5 */ return 0;} void main(){ int x, y; /* main::x */ x = 111; /* 1 */ printf(x=%d\n, x); /* 2 */ printf(glob=%d\n, globvar); /* 3 */ y = f1(); y = f2();} В данном примере мы видим:- во-первых мы видим ФУНКЦИИ БЕЗ ПАРАМЕТРОВ. Это нормальная ситуация.- во-вторых тут используются ТРИ переменные с именем x. Как выполняется программа? /* 1 */ main::x = 111; Это локальный x, а не глобальный. Глобальный x попрежнему содержит 12. /* 2 */ Напечатает значение переменной main::x, то есть 111. Внутри функции main глобальная переменная ::x заслонена своей собственной переменной x. В данном случае НЕТ СПОСОБА добраться из main к глобальной переменной x, это возможно только в языке Си++ по имени ::x К переменной же globvar у нас доступ есть. /* 3 */ Печатает ::globvar. Мы обнаруживаем, что ее значение 0. В отличие от глобальных переменных, которые изначально содержат МУСОР, глобальные переменные изначально содержат значение 0. В рамочку, подчеркнуть. /* 4 */ При вызове f1() переменная f1::x заслоняет собой как main::x так и ::x В данном случае напечатается 77, но ни ::x ни main::x не будут изменены оператором x = 77. Это изменялась f1::x /* 5 */ При вызове f2() история интереснее. Тут нет своей собственной переменной x. Но какая переменная печатается тут — ::x или main::x ? Ответ: ::x то есть 12. Переменные названы локальными еще и потому, что они НЕВИДИМЫ В ВЫЗЫВАЕМЫХ ФУНКЦИЯХ. Это ОПРЕДЕЛЕНИЕ локальных переменных. (Поэтому не спрашивайте почему? По определению) То есть, если мы имеем funca(){ int vara; … …funcb();… /* вызов */ … } то из функции funcb() мы НЕ ИМЕЕМ ДОСТУПА К ПЕРЕМЕННОЙ vara. funcb(){ int z; z = vara + 1; /* ошибка, vara неизвестна внутри funcb() */ } Если, в свою очередь, funcb() вызывает funcc(), то и из funcc() переменная vara невидима. Остановитесь и осознайте. Это правило служит все той же цели — разные функции могут быть написаны разными программистами, которые могут использовать одни и те же имена для РАЗНЫХ переменных, не боясь их взаимопересечения. Множества имен, использованных в разных функциях, независимы друг от друга. Имена из одной функции НИКАК не относятся к переменным с теми же именами ИЗ ДРУГОЙ функции. Вернемся к параграфу КАК ПРОИСХОДИТ ВЫЗОВ ФУНКЦИИ и рассмотрим пункт (a). Теперь он может быть описан как (a) Локальные переменные и аргументы вызывающей функции делаются невидимыми. ~~~~~~~~~~ А при возврате из функции: (5) Локальные переменные и аргументы вызывающей функции снова делаются видимыми. ОДНАКО глобальные переменные видимы из ЛЮБОЙ функции, исключая случай, когда глобальная переменная заслонена одноименной локальной переменной данной функции. ————————————————————————-ПРОЦЕДУРЫ=========Бывают функции, которые не возвращают никакого значения.Такие функции обозначаются void (пустышка).Такие функции называют еще ПРОЦЕДУРАМИ. void func(){ printf(Приветик!\n); return; /* вернуться в вызывающую функцию */ } Такие функции вызываются ради побочных эффектов,например печати строчки на экран или изменения глобальных (и только)переменных. int glob; void func(int a){ glob += a; } Оператор return тут необязателен, он автоматически выполняетсяперед последней скобкой } Вызов таких функций не может быть использованв операторе присваивания: main(){ int z; z = func(7); /* ошибка, а что мы присваиваем ??? */} Корректный вызов таков: main(){ func(7);} Просто вызов и все.

ЗАЧЕМ ФУНКЦИИ?

Чтобы вызывать их с разными аргументами! int res1, res2; … res1 = func(12 * x * x + 177, 865, ‘x’); res2 = func(432 * y + x, 123 * y — 12, ‘z’); Кстати, вы заметили, что список фактических параметровследует через запятую;и выражений ровно столько, сколько параметров у функции? Функция описывает ПОСЛЕДОВАТЕЬНОСТЬ ДЕЙСТВИЙ,которую можно выполнить много раз,но с разными исходными данными (аргументами).В зависимости от данных она будет выдавать разные результаты,но выполняя одни и те же действия. В том то и состоит ее прелесть:мы не дублируем один кусок программы много раз,а просто вызываем его. Функция — абстракция АЛГОРИТМА, то есть последовательности действий.Ее конкретизация — вызов функции с уже определенными параметрами.————————————————————————-Оператор return может находиться не только в конце функции,но и в ее середине.Он вызывает немедленное прекращение тела функции и возврат значенияв точку вызова. int f(int x){ int y; y = x + 4; if(y10) return (x — 1); y *= 2; return (x + y); }

РЕКУРСИВНЫЕ ФУНКЦИИ. СТЕК

Рекурсивной называется функция, вызывающая сама себя. int factorial(int arg){ if(arg == 1) return 1; /* a */ else return arg * factorial(arg — 1); /* b */ } Эта функция при вызове factorial(n) вычислит произведение n * (n-1) * … * 3 * 2 * 1 называемое факториал числа n.В данной функции переменная arg будет отведена (а после и уничтожена) МНОГО РАЗ. Так что переменная factorial::arg должна получить еще и НОМЕР вызова функции: factorial::arg[уровень_вызова] И на каждом новом уровне новая переменная скрывает все предыдущие.Так для factorial(4) будет +—————————————-+ | | factorial::arg[ 0_ой_раз ] есть 4 | | | factorial::arg[ 1_ый_раз ] есть 3 | | | factorial::arg[ 2_ой_раз ] есть 2 | | | factorial::arg[ 3_ий_раз ] есть 1 | V ———+ +——— Затем пойдут возвраты из функций: +—————————————-+ A | /* b */ return 4 * 6 = 24 | | | /* b */ return 3 * 2 = 6 | | | /* b */ return 2 * 1 = 2 | | | /* a */ return 1; | | ———+ +——— Такая конструкция называется СТЕК (stack). ———+ +———— | | пустой стек +—————+ Положим в стек значение a | ———+ | +———— | V | +—————+ | a |0){ printf(top=%d\n, pop()); } }

СТЕК И ФУНКЦИИ

Будем рассматривать каждый ВЫЗОВ функции как помещение в специальный стекбольшого блока информации, включающего в частностиАРГУМЕНТЫ И ЛОКАЛЬНЫЕ ПЕРЕМЕННЫЕ вызываемой функции. Оператор return из вызванной функции выталкивает со стека ВЕСЬ такой блок. В качестве примера рассмотрим такую программу: int x = 7; /* глобальная */int v = 333; /* глобальная */ int factorial(int n){ int w; /* лишняя переменная, только для демонстрационных целей */ w = n; if(n == 1) return 1; /* #a */ else return n * factorial(n-1); /* #b */}void func(){ int x; /* func::x */ x = 777; /* #c */ printf(Вызвана функция func()\n);}void main(){ int y = 12; /* main::y */ int z; /* A */ z = factorial(3); /* B */ printf(z=%d\n, z); func(); /* C */}————————————————————————-Выполнение программы начнется с вызова функции main().В точке /* A */ | в з г л я д | V V ———+ +——— |=======================| | z = мусор | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ В каждый данный момент видимы переменные, которые находятсяa) на вершине (и только) стека вызовов функций.b) и незаслоненные ими глобальные переменные.В данном случае мы смотрим сверху и видим: main::z, main::y, ::x, ::v ————————————————————————-В точке /* B */ мы вызываем factorial(3). ———+ +——— |=======================| | w = мусор | | n = 3 | |factorial(3) | |=======================| | +-|— текущий оператор z = factorial(3); | z = мусор | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ При новом взгляде видимы: factorial(3)::w, factorial(3)::n, ::x, ::v Стали невидимы: main::z, main::y Строка текущий оператор … указывает место, с которого надо возобновитьвыполнение функции, когда мы вернемся в нее.————————————————————————-Когда выполнение программы в функции factorial(3) дойдет до точки/* #b */ будет выполняться return 3 * factorial(2).В итоге будет вызвана функция factorial(2). ———+ +——— |=======================| | w = мусор | | n = 2 | |factorial(2) | |=======================| | +-|— текущий оператор return 3 * factorial(2); | w = 3 | | n = 3 | |factorial(3) | |=======================| | +-|— текущий оператор z = factorial(3); | z = мусор | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ————————————————————————-Когда выполнение программы в функции factorial(2) дойдет до точки/* #b */ будет выполняться return 2 * factorial(1).В итоге будет вызвана функция factorial(1). ———+ +——— |=======================| | w = мусор | | n = 1 | |factorial(1) | |=======================| | +-|— текущий оператор return 2 * factorial(1); | w = 2 | | n = 2 | |factorial(2) | |=======================| | +-|— текущий оператор return 3 * factorial(2); | w = 3 | | n = 3 | |factorial(3) | |=======================| | +-|— текущий оператор z = factorial(3); | z = мусор | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ————————————————————————-Затем в factorial(1) выполнение программы дойдет до точки /* #a */и будет производиться return 1. При return вычеркивается ОДИН блок информации со стека вызовов функций,и возобновляется выполнение текущего оператора в функции,ставшей НОВОЙ вершиной стека вызовов.Заметьте, что в данной ситуации вызванные функции factorial(m) еще не завершились.В них еще ЕСТЬ что сделать: вычислить выражение в return,и собственно выполнить сам return. Вычисления будут продолжены. ———+ +——— |=======================| | +-|— текущий оператор return 1; | w = 1 | | n = 1 | |factorial(1) | |=======================| | +-|— текущий оператор return 2 * factorial(1); | w = 2 | | n = 2 | |factorial(2) | |=======================| | +-|— текущий оператор return 3 * factorial(2); | w = 3 | | n = 3 | |factorial(3) | |=======================| | +-|— текущий оператор z = factorial(3); | z = мусор | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ————————————————————————-Начинается выталкивание функций со стека и выполнение операторов return; ———+ +——— |=======================| | +-|— текущий оператор return 2 * 1; | w = 2 | | n = 2 | |factorial(2) | |=======================| | +-|— текущий оператор return 3 * factorial(2); | w = 3 | | n = 3 | |factorial(3) | |=======================| | +-|— текущий оператор z = factorial(3); | z = мусор | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ———+ +——— |=======================| | +-|— текущий оператор return 3 * 2; | w = 3 | | n = 3 | |factorial(3) | |=======================| | +-|— текущий оператор z = factorial(3); | z = мусор | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ———+ +——— |=======================| | +-|— текущий оператор z = 6; | z = мусор | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ———+ +——— |=======================| | z = 6 | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ ————————————————————————-Наконец, в точке /* C */ будет вызвана функция func().Рассмотрим точку /* #c */ в ней. ———+ +——— |=======================| | x = 777; | |func(); | |=======================| | +-|— текущий оператор func(); | z = 6 | | y = 12 | +——+———+ |main() | |x = 7 | v = 333 | +————————+————+——+———+—— СТЕК ВЫЗОВОВ ФУНКЦИЙ ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ В данном месте нас интересует — какие переменные видимы?Видимы: func::x = 777 ::v = 333 И все. ::x заслонен локальной переменной. main::y, main::z невидимы, так как находятся не на вершине стека вызовов функций————————————————————————-Многие функции более естественно выражаются через рекурсию.Хотя, часто это приводит к излишним вычислениям по сравнению с итерациями(то есть циклами). Вот пример — числа Фибоначчи. int fibonacci(int n){ if(n==1 || n==2) return 1; /* else */ return fibonacci(n-1) + fibonacci(n-2);}void main(){ printf(20ое число Фибоначчи равно %d\n, fibonacci(20));} Поскольку тут отсутствует массив для запоминания промежуточныхрезультатов, то этот массив на самом деле неявно моделируетсяв виде локальных переменных внутри стека вызовов функций.Однако этот способ плох — в нем слишком много повторяющихсядействий. Добавим оператор печати — и посчитаем, сколько разбыла вызвана fibonacci(1) ? int called = 0; int fibonacci(int n){ if(n==1){ called++; return 1; } else if(n==2) return 1; return fibonacci(n-1) + fibonacci(n-2);}void main(){ printf(20ое число Фибоначчи равно %d\n, fibonacci(20)); printf(fibonacci(1) была вызвана %d раз\n, called);} Она была вызвана… 2584 раза!

/* Рисуем хитрую геометрическую фигуру */#includeconst int LINES = 15; void draw(int nspaces, int nstars, char symbol){ int i; for(i=0; inspaces; i++) putchar(‘ ‘); for(i=0; instars; i++) putchar(symbol);} void main(){ int nline, nsym; char symbols[3]; /* Массив из трех букв */ symbols[0] = ‘\\’; symbols[1] = ‘o’; symbols[2] = ‘*’; for(nline=0; nlineLINES; nline++){ for(nsym = 0; nsym3; nsym++) draw(nline, nline, symbols[nsym]); /* Переход на новую строку вынесен из функции в главный цикл */ putchar(‘\n’); }}

/* Задача: нарисовать таблицу вида кот кот кот кошка кошка кот кот кот кошка кошка кот … Где идет последовательность кот, кот, кот, кошка, кошка… повторяющаяся много раз и располагаемая по 6 зверей в строку.*/ #include/* магическая строка */ /* Объявление глобальных переменных. В данном случае — констант. */ int TOMCATS = 3; /* три кота */int CATS = 2; /* две кошки */int ANIMALS_PER_LINE = 6; /* шесть зверей в каждой строке */int LINES = 25; /* число выводимых строк */ /* и нам понадобится еще одна переменная — общее число зверей. Ее мы вычислим через уже заданные, поэтому тут мы ее объявим… но вычислить что-либо можно только внутри функции. В нашем случае — в функции main().*/int ANIMALS; /* общее число зверей */ int nth_in_line = 0; /* номер зверя в текущей строке *//* Эта переменная не может быть локальной в функции, так как * тогда она уничтожится при выходе из функции. Нам же необходимо, * чтобы ее значение сохранялось. Поэтому переменная — глобальная. */ /* Функция, которая считает число зверей в одной строке и либо переводит строку, либо переводит печать в следующую колонку (табуляцией).*/void checkIfWeHaveToBreakLine(){ nth_in_line++; /* текущий номер зверя в строке (с единицы) */ if(nth_in_line == ANIMALS_PER_LINE){ /* Если строка заполнена зверьми… */ putchar(‘\n’); /* новая строка */ nth_in_line = 0; /* в новой строке нет зверей */ } else { putchar(‘\t’); /* в следующую колонку */ }} void main(){ int nanimal; /* номер зверя */ int i; /* счетчик */ ANIMALS = ANIMALS_PER_LINE * LINES; nanimal = 0; while(nanimalANIMALS){ for(i=0; iTOMCATS; i++){ /* Оператор printf() выводит СТРОКУ СИМВОЛОВ. СТРОКА заключается в двойные кавычки (не путать с одиночными для putchar(). */ printf(кот); nanimal++; /* посчитать еще одного зверя */ /* и проверить — не надо ли перейти на новую строку ? */ checkIfWeHaveToBreakLine(); } for(i=0; iCATS; i++){ printf(кошка); nanimal++; /* посчитать еще одного зверя */ /* и проверить — не надо ли перейти на новую строку ? */ checkIfWeHaveToBreakLine(); } } /* putchar(‘\n’); */}

Статьи к прочтению:

Надо радоваться, не надо напрягаться!.mp4

Похожие статьи: