Перейти на главную   
  helloworld.ru - документация и книги по программированию  
helloworld.ru - документация и книги по программированию    
    главная     хостинг     создание сайтов    
Поиск по сайту:  
Смотрите также
Языки программирования
C#
MS Visual C++
Borland C++
C++ Builder
Visual Basic
Quick Basic
Turbo Pascal
Delphi
JavaScript
Java
PHP
Perl
Assembler
AutoLisp
Fortran
Python
1C

Интернет-технологии
HTML
VRML
HTTP
CGI
FTP
Proxy
DNS
протоколы TCP/IP
Apache

Web-дизайн
HTML
Дизайн
VRML
PhotoShop
Cookie
CGI
SSI
CSS
ASP
PHP
Perl

Программирование игр
DirectDraw
DirectSound
Direct3D
OpenGL
3D-графика
Графика под DOS

Алгоритмы
Численные методы
Обработка данных

Системное программирование
Драйверы

Базы данных
MySQL
SQL

Другое

Хостинг


Друзья
demaker.ru
Реклама

Лучший хостинг. Аренда серверов




helloworld.ru

Руководство полного идиота по программированию (на языке Си)

Aндрей Богатырев

     ПЕРЕМЕННЫЕ

Переменная - это такой "ящичек" с именем,
в котором может храниться некое ЗНАЧЕНИЕ.
Имя у переменной постоянно и неизменно,
значение же может меняться.

Например, пусть у нас есть переменная с именем "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");
  ------------------------------------------------------------------------

Самое сложное - привыкнуть к тому, что сравнение обозначается знаком ==,
а не =
Знак = означает "присвоить значение", а не "сравнить на равенство".

     ЦИКЛ 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(){
                ...
        }
  ------------------------------------------------------------------------

Пример программы:

#include

int 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; i < 4; 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; i < 10; 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; i < 10; i++)
                funcN(i);

Заметьте, что цикл теперь начинается с индекса 3.

А теперь - случай, где смесь цикла и условного оператора оправдана:

        int i;

        for(i=0; i < 100; i++){
                if((i % 2) == 0) even();        /* четный */
                else             odd();         /* нечетный */
        }

Тут в цикле проверяется четность индекса i.
     03.c

/* Треугольник из звездочек */

#include

/* putchar('c') - печатает одинокий символ c */
/* символ \n - переводит строку              */
/* nstars - сколько звездочек напечатать     */

/* Функция рисования одной строки треугольника */
void drawOneLine(int nstars){
        int i;          /* номер печатаемой звездочки, счетчик */

        for(i=0; i < nstars; i++)  /* Рисуем nstars звездочек подряд  */
                putchar('*');
        putchar('\n');             /* И переходим на следующую строку */
}

void main(){
        /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */
        int nline;      /* номер строки */

        /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */
        for(nline=1; nline <= 25; nline++)
                drawOneLine(nline);
        /* сколько звездочек? столько же, каков номер строки */
}
     04.c

/* Треугольник из звездочек */
/* Тот же пример со вложенным циклом, а не с функцией */

#include

void main(){
        /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */
        int nline;      /* номер строки */
        int i;          /* номер печатаемой звездочки, счетчик */

        /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */
        for(nline=1; nline <= 25; nline++){
                /* сколько звездочек? столько же, каков номер строки */
                for(i=0; i < nline; i++)
                        putchar('*');
                putchar('\n');
        }
}
     05.c

/* Треугольник из звездочек */
/* Теперь треугольник должен быть равнобедренным */

#include

/* nstars  - сколько звездочек напечатать     */
/* nspaces - сколько пробелов напечатать перед звездочками */

void drawOneLine(int nspaces, int nstars){
        int i;          /* номер печатаемой звездочки, счетчик */
                        /* он же - номер печатаемого пробела   */

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nstars; 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; nline <= LINES; nline++)
                drawOneLine(LINES - nline,   /* число пробелов  --> nspaces */
                            nline*2 - 1      /* число звездочек --> nstars */
                           );
}
     06.c

/* Треугольник из звездочек */
/* Теперь треугольник должен быть равнобедренным */

#include

void drawOneLine(int nspaces, int nstars){
        int i;          /* номер печатаемой звездочки, счетчик */
                        /* он же - номер печатаемого пробела   */

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nstars; i++)
                putchar('*');
        putchar('\n');
}

void main(){
        /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */
        int LINES = 25; /* всего строк. */
        int nline;      /* номер строки */

        /* Для человека естественно считать с 1.
           Для машины же первое число - это НУЛЬ.
           Поэтому цикл
                for(nline=1; nline <= LINES; nline++)
           Следует записать в виде
                for(nline=0; nline <  LINES; nline++)

           Он тоже выполнится 25 раз, но значение переменной-счетчика
                nline будет на каждой итерации на 1 меньше. Поэтому надо
                поменять расчет параметров для функции рисования.

                        n (номер строки)
     ...*               0
     ..***              1
     .*****             2
     *******            3

        Всего строк:                                    LINES
        Число звездочек в n-ой строке:                  n*2 + 1
        Число пробелов спереди (обозначены точкой):     LINES - n - 1

        */

        /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */
        for(nline=0; nline < LINES; nline++)
                drawOneLine(LINES - nline - 1, nline*2 + 1);
}
     07.c

/*
        Тип переменных для хранения БУКВ называется

                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 -
 каким символом рисовать строку.

 Далее в основном цикле используем условный оператор и
 проверку номера строки на четность.

*/

#include

void drawOneLine(int nspaces, int nsymbols, char symbol){
        int i;          /* счетчик */

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nsymbols; i++)
                putchar(symbol);
        putchar('\n');
}

/* Мы вынесем объявление этой переменной из функции,
   сделав ее "глобальной", то есть видимой во ВСЕХ функциях.
 */
int LINES = 25; /* всего строк. */

void main(){
        /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */
        int nline;      /* номер строки */

        /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */
        for(nline=0; nline <  LINES; nline++){

                if((nline % 2) == 0)    /* четное ? */
                        drawOneLine(LINES - nline - 1, nline*2 + 1, '+');
                else    drawOneLine(LINES - nline - 1, nline*2 + 1, '*');
        }
}
     08.c

/* То же самое, но теперь нужно еще и печатать номер строки.
 */

#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; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nsymbols; i++)
                putchar(symbol);
        putchar('\n');
}

void main(){
        /* ОБЪЯВЛЕНИЕ ПЕРЕМЕННЫХ */
        int nline;      /* номер строки */

        /* ВЫПОЛНЯЕМЫЕ ОПЕРАТОРЫ (ДЕЙСТВИЯ) */
        for(nline=0; nline <  LINES; 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 ?
         */
}
     09.c

/* Следующая задача будет касаться того,
   чтобы каждая строка треугольника печаталась
   в виде:
        *+*+*+*.....*+*

   Тут нам уже придется модифицировать функцию рисования строки.
*/

#include

int LINES = 25; /* всего строк. */

void drawOneLine(int nspaces, int nsymbols){
        int i;

        for(i=0; i < nspaces; i++)
                putchar(' ');

        /* в цикле мы будем проверять на четность НОМЕР
           печатаемого символа.
         */
        for(i=0; i < nsymbols; i++){
                if((i % 2) == 0)
                        putchar('*');
                else    putchar('+');
        }
        putchar('\n');
}

void main(){
        int nline;      /* номер строки */

        for(nline=0; nline <  LINES; nline++) {
                drawOneLine(LINES - nline - 1, nline*2 + 1);
        }
}
     10.c

/* Задача нарисовать РОМБ:
        *
       ***
      *****
       ***
        *
*/

#include

int LINES = 10; /* всего строк в половине ромба. */

void drawOneLine(int nspaces, int nsymbols){
        int i;

        for(i=0; i < nspaces; i++)
                putchar(' ');

        for(i=0; i < nsymbols; i++)
                putchar('+');
        putchar('\n');
}

void main(){
        int nline;      /* номер строки */

        for(nline=0; nline <  LINES; nline++)
                drawOneLine(LINES - nline - 1, nline*2 + 1);

        /* Мы нарисовали треугольник.
           Теперь нам нужен перевернутый треугольник.
           Пишем цикл по убыванию индекса.
           С данного места номера строк отсчитываются в обратном порядке:
           от LINES-2 до 0
         */

        for(nline=LINES-2; nline >= 0; nline--)
                drawOneLine(LINES - nline - 1, nline*2 + 1);
}
     11.c

/* А теперь рисуем ромб, используя математические формулы. */

#include

void draw(int nspaces, int nstars, char symbol){
        int i;

        for(i=0; i < nspaces; i++)
                putchar(' ');
        for(i=0; i < nstars; i++)
                putchar(symbol);
        putchar('\n');
}

void main(){
        int LINES = 21;
        int MIDDLELINE = LINES/2 + 1;   /* середина ромба */
        int nline;

        for(nline=0; nline < MIDDLELINE; nline++)
                draw(MIDDLELINE - nline -1, nline*2+1, 'A');

        /* У следующего цикла for() нет инициализации
           начального значения индекса.
           Начальное nline наследуется из предыдущего цикла,
           таким, каким оно осталось после его окончания, то есть
           равным MIDDLELINE.
         */

        for( ; nline < LINES; 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 <= n < N)
используется имя ящика

        var[n]

где n - целое значение (или значение целой переменной,
или целочисленного выражения), "индекс в массиве".
Эта операция [] называется "индексация массива".
Индексация - есть ВЫБОР одного из N ящиков при помощи указания целого номера.
        var    - массив (N ячеек)
        n      - выражение (формула), выдающая целое значение в интервале 0..N-1
        var[n] - взят один из элементов массива. Один из всех.
        n      - номер ящика - называется еще и "индексом" этой переменной в массиве.

Пример:

        int var[5];                                     /* 1 */

        var[0] = 2;                                     /* 2 */
        var[1] = 3 + var[0];                            /* 3 */
        var[2] = var[0] * var[1];                       /* 4 */
        var[3] = (var[0] + 4) * var[1];                 /* 5 */

        printf("var третье есть %d\n", var[3]);

В ходе этой программы элементы массива меняются таким образом:

          var[0]    var[1]     var[2]     var[3]    var[4]
          ------------------------------------------------
/* 1 */   мусор     мусор      мусор      мусор     мусор
/* 2 */   2         мусор      мусор      мусор     мусор
/* 3 */   2         5          мусор      мусор     мусор
/* 4 */   2         5          10         мусор     мусор
/* 5 */   2         5          10         30        мусор

Как видим, каждый оператор изменяет лишь ОДНУ ячейку массива за раз.

Массив - набор переменных, которые не ИМЕНОВАНЫ разными именами,
вроде var0, var1, var2, ...
а ПРОНУМЕРОВАНЫ под одним именем:
var[0], var[1], var[2], ...

Индекс - часть ИМЕНИ ПЕРЕМЕННОЙ.

На самом деле индексация - это
        1) выбор элемента в массиве
        2) справа от присваиваний и в выражениях - еще и разыменование,
           то есть взятие вместо имени переменной - значения, в ней хранящегося.
  ------------------------------------------------------------------------

Если в переменную не было занесено значение,
а мы используем эту переменную,
то в ней лежит МУСОР (любое, непредсказуемое значение).

        printf("var4 есть %d\n", var[4]);

напечатает все что угодно.

Поэтому переменные надо всегда инициализировать
(давать им начальное значение).

Глобальные переменные автоматически инициализируются нулем,
если мы не задали иначе.

Локальные переменные не инициализируются автоматически, и содержат МУСОР.
  ------------------------------------------------------------------------

Массивы НЕЛЬЗЯ присваивать целиком, язык Си этого не умеет.

        int a[5];
        int b[5];

        a = b;  /* ошибка */

Также нельзя присвоить значение сразу всем элементам (ячейкам) массива:

        a = 0;  /* ошибка */

не делает того, что нами ожидалось, а является ошибкой.

[ Далее ]










helloworld.ru © 2001-2016
Все права защищены
Rambler's Top100 TopList Rambler's Top100