Единственный способ освоить новый язык программирования - писать на нем программы. Первая программа, которая должна быть написана, - одна для всех языков: напечатать слова : hello, world.
    Это - самый существенный барьер; чтобы преодолеть его, Вы должны суметь завести где-то текст программы, успешно его скомпилировать, загрузить, прогнать и найти, где оказалась ваша выдача. Если Вы научились справляться с этими техническими деталями, все остальное сравнительно просто. Программа печати "hello, world" на языке "C" имеет вид:

    main ()
    {
            printf("hello, world\n");
    }

Как пропустить эту программу - зависит от используемой вами системы. В частности, на операционной системе "UNIX" Вы должны завести исходную программу в файле, имя которого оканчивается на ".c" , например, hello.c , и затем скомпилировать ее по команде

            cc hello.c

Если Вы не допустили какой-либо небрежности , такой как пропуск символа или неправильное написание, компиляция пройдет без сообщений и будет создан исполняемый файл с именем а.out . Прогон его по команде

               a.out

           hello, world

    Упражнение 1-1.
Пропустите эту программу на вашей системе. Попробуйте не включать различные части программы и посмотрите какие сообщения об ошибках Вы при этом получите.

    Теперь некоторые пояснения к самой программе. Любая "C"-программа, каков бы ни был ее размер, состоит из одной или более "функций", указывающих фактические операции компьютера, которые должны быть выполнены. Функции в языке "C" подобны функциям и подпрограммам фортрана и процедурам PL/1, Паскаля и т.д. В нашем примере такой функцией является main. Обычно Вы можете давать функциям любые имена по вашему усмотрению, но main - это особое имя; выполнение вашей программы начинается сначала с функции main. Это означает, что каждая программа должна в каком-то месте содержать функцию с именем main. Для выполнения определенных действий функция main обычно обращается к другим функциям, часть из которых находится в той же самой программе, а часть - в библиотеках, содержащих ранее написанные функции. Одним способом обмена данными между функциями является передача посредством аргументов. Круглые скобки, следующие за именем функции, заключают в себе список аргументов; здесь маin - функция без аргументов, что указывается как (). Операторы, составляющие функцию, заключаются в фигурные скобки { и }, которые аналогичны do-end в PL/1 или begin-end в алголе, Паскал е и т.д. Обращение к функции осуществляется указанием ее имени, за которым следует заключенный в круглые скобки список аргументов. здесь нет никаких операторов call, как в фортране или PL/1. Круглые скобки должны присутствовать и в том случае, когда функция не имеет аргументов. Строка

      printf("hello, world\n");

    является обращением к функции, которое вызывает функцию с именем printf и аргуметом "hello, world\n". Функция printf является библиотечной функцией, которая выдает выходные данные на терминал (если только не указано какое-то другое место назначения). В данном случае печатается строка символов, являющаяся аргументом функции.
    Последовательность из любого количества символов, заключенных в удвоенные кавычки "...", называется 'символьной строкой' или 'строчной константой'. Пока мы будем использовать символьные строки только в качестве аргументов для printf и других функций.
    Последовательность \n в приведенной строке является обозначением на языке "C" для 'символа новой строки', который служит указанием для перехода на терминале к левому краю следующей строки. Если Вы не включите \n (полезный эксперимент), то обнаружите, что ваша выдача не закончится переходом терминала на новую строку. Использование последовательности \n - единственный способ введения символа новой строки в аргумент функции printf; если Вы попробуете что-нибудь вроде

          printf("hello, world
          ");

    то "C"-компилятор будет печатать злорадные диагностические сообщения о недостающих кавычках. Функция printf не обеспечивает автоматического перехода на новую строку, так что многократное обращение к ней можно использовать для поэтапной сборки выходной строки. Наша первая программа, печатающая идентичную выдачу, с точно таким же успехом могла бы быть написана в виде

     main()
     {
             printf("hello, ");
             printf("world");
             printf("\n");
     }

    Подчеркнем, что \n представляет только один символ. Условные 'последовательности', подобные \n , дают общий и допускающий расширение механизм для представления трудных для печати или невидимых символов. Среди прочих символов в языке "C" предусмотрены следующие: \t - для табуляции, \b - для возврата на одну позицию, \" - для двойной кавычки и \\ для самой обратной косой черты.     Упражнение 1-2.

    Теперь сама программа:

    /* print fahrenheit-celsius table
    for f = 0, 20, ..., 300 */
    main()
    {
    int lower, upper, step;
    float fahr, celsius;

    lower = 0;  /* lower limit of temperature
    table */
    upper =300; /* upper limit */
    step  = 20; /* step size */
    fahr = lower;
    while (fahr <= upper) {
      celsius = (5.0/9.0) * (fahr -32.0);
      printf("%4.0f %6.1f\n", fahr, celsius);
      fahr = fahr + step;
    }
    }

Первые две строки

    /* print fahrenheit-celsius table
         for  f  = 0, 20, ..., 300 */

    являются комментарием, который в данном случае кратко поясняет, что делает программа. Любые символы между /* и */ игнорируются компилятором; можно свободно пользоваться комментариями для облегчения понимания программы. Комментарии могут появляться в любом месте, где возможен пробел или переход на новую строку.
    В языке "C" все переменные должны быть описаны до их использования, обычно это делается в начале функции до первого выполняемого оператора. Если Вы забудете вставить описание, то получите диагностическое сообщение от компилятора. Описание состоит из типа и списка переменных, имеющих этот тип, как в

     int lower, upper, step;
     float fahr, celsius;

    Тип int означает, что все переменные списка целые; тип float предназначен для чисел с плавающей точкой, т.е. для чисел, которые могут иметь дробную часть. Точность как int , tak и float зависит от конкретной машины, на которой Вы работаете. На PDP-11, например, тип int соответствует 16-битовому числу со знаком, т.е. числу, лежащему между -32768 и +32767. Число типа float - это 32-битовое число, имеющее около семи значащих цифр и лежащее в диапазоне от 10е-38 до 10е+38. В главе 2 приводится список размеров для других машин. В языке "C" предусмотрено несколько других основных типов данных, кроме int и float:

char символ - один байт
short короткое целое
long длинное целое
double плавающее с двойной точностью

    Размеры этих объектов тоже машинно-независимы; детали приведены в главе 2. Имеются также массивы, структуры и объединения этих основных типов, указатели на них и функции,которые их возвращают; со всеми ними мы встретимся в свое время.

    Фактически вычисления в программе перевода температур начинаются с операторов присваивания lower = 0; upper =300; step = 20; fahr =lower; которые придают переменным их начальные значения. каждый отдельный оператор заканчивается точкой с запятой.
    Каждая строка таблицы вычисляется одинаковым образом, так что мы используем цикл, повторяющийся один раз на строку. В этом назначение оператора while:

while (fahr <= upper) {
....
}

    проверяется условие в круглых скобках. Если оно истинно (fahr меньше или равно upper), то выполняется тело цикла (все операторы, заключенные в фигурные скобки { и } ). Затем вновь проверяется это условие и, если оно истинно, опять выполняется тело цикла. Если же условие не выполняется ( fahr превосходит upper ), цикл заканчивается и происходит переход к выполнению оператора, следующего за оператором цикла. Так как в настоящей программе нет никаких последующих операторов, то выполнение программы завершается. Тело оператора while может состоять из одного или более операторов, заключенных в фигурные скобки, как в программе перевода температур, или из одного оператора без скобок, как, например, в

     while (i < j)
           i = 2 * i;

    В обоих случаях операторы, управляемые оператором while, сдвинуты на одну табуляцию, чтобы Вы могли с первого взгляда видеть, какие операторы находятся внутри цикла. Такой сдвиг подчеркивает логическую структуру программы. Хотя в языке "C" допускается совершенно произвольное расположение операторов в строке, подходящий сдвиг и использование пробелов значительно облегчают чтение программ. Мы рекомендуем писать только один оператор на строке и (обычно) оставлять пробелы вокруг операторов. Расположение фигурных скобок менее существенно; мы выбрали один из нескольких популярных стилей. Выберите подходящий для Вас стиль и затем используйте его последовательно. Основная часть работы выполняется в теле цикла. Температура по Цельсию вычисляется и присваивается переменной celsius оператором

      celsius = (5.0/9.0) * (fahr-32.0);

    причина использования выражения 5.0/9.0 вместо выглядящего проще 5/9 заключается в том, что в языке "C", как и во многих других языках, при делении целых происходит усечение, состоящее в отбрасывании дробной части результата. Таким образом, результат операции 5/9 равен нулю, и, конечно, в этом случае все температуры оказались бы равными нулю. Десятичная точка в константе указывает, что она имеет тип с плавающей точкой, так что, как мы и хотели, 5.0/9.0 равно 0.5555... . Мы также писали 32.0 вместо 32 , несмотря на то, что так как переменная fahr имеет тип float , целое 32 автоматически бы преобразовалось к типу float ( в 32.0) перед вычитанием. С точки зрения стиля разумно писать плавающие константы с явной десятичной точкой даже тогда, когда они имеют целые значения; это подчеркивает их плавающую природу для просматривающего программу и обеспечивает то, что компилятор будет смотреть на вещи так же, как и Вы. Подробные правила о том, в каком случае целые преобразуются к типу с плаваюшей точкой, приведены в главе 2. Сейчас же отметим, что присваивание

            fahr = lower;

    проверка

            while (fahr <= upper)

    работают, как ожидается, - перед выполнением операций целые преобразуются в плавающую форму. Этот же пример сообщает чуть больше о том, как работает printf. Функция printf фактически является универсальной функцией форматных преобразований, которая будет полностью описана в главе 7. Ее первым аргументом является строка символов, которая должна быть напечатана, причем каждый знак % указывает, куда должен подставляться каждый из остальных аргументов /второй, третий, .../ и в какой форме он должен печататься. Например, в операторе

   printf("%4.0f %6.1f\n", fahr, celsius);

    спецификация преобразования %4.0f говорит, что число с плавающей точкой должно быть напечатано в поле шириной по крайней мере в четыре символа без цифр после десятичной точки. спецификация %6.1f описывает другое число, которое должно занимать по крайней мере шесть позиций с одной цифрой после десятичной точки, аналогично спецификациям f6.1 в фортране или f(6,1) в PL/1. Различные части спецификации могут быть опущены: спецификация %6f говорит, что число будет шириной по крайней мере в шесть символов; спецификация %2 требует двух позиций после десятичной точки, но ширина при этом не ограничивается; спецификация %f говорит только о том, что нужно напечатать число с плавающей точкой. Функция printf также распознает следующие спецификации: %d - для десятичного целого, %о - для восьмеричного числа, %х - для шестнадцатиричного, %с - для символа, %s - для символьной строки и %% - для самого символа %.
    Каждая конструкция с символом % в первом аргументе функции printf сочетается с соответствующим вторым, третьим, и т.д. Аргументами; они должны согласовываться по числу и типу; в противном случае Вы получите бессмысленные результаты. Между прочим, функция printf не является частью языка "C"; в самом языке "C" не определены операции ввода-вывода. Нет ничего таинственного и в функции printf ; это - просто полезная функция, являющаяся частью стандартной библиотеки подпрограмм, которая обычно доступна "C"-программам. Чтобы сосредоточиться на самом языке, мы не будем подробно останавливаться на операциях ввода-вывода до главы 7. В частности, мы до тех пор отложим форматный ввод. Если вам надо ввести числа - прочитайте описание функции scanf в главе 7, раздел 7.4. Функция scanf во многом сходна с printf , но она считывает входные данные, а не печатает выходные.

    Упражнение 1-3.
    Преобразуйте программу перевода температур таким образом, чтобы она печатала заголовок к таблице.

    Эта программа выдает те же самые результаты, но выглядит безусловно по-другому. Главное изменение - исключение большинства переменных; осталась только переменная fahr , причем типа int (это сделано для того, чтобы продемонстрировать преобразование %d в функции printf). Нижняя и верхняя границы и размер щага появляются только как константы в операторе for , который сам является новой конструкцией, а выражение, вычисляющее температуру по Цельсию, входит теперь в виде третьего аргумента функции printf , а не в виде отдельного оператора присваивания.
    Последнее изменение является примером вполне общего правила языка "C" - в любом контексте, в котором допускается использование значения переменной некоторого типа, Вы можете использовать выражение этого типа. Так как третий аргумент функции printf должен иметь значение с плавающей точкой, чтобы соответствовать спецификации %6.1f, то в этом месте может встретиться любое выражение плавающего типа. Сам оператор for - это оператор цикла, обобщающий оператор while. Его функционирование должно стать ясным, если Вы сравните его с ранее описанным оператором while . Оператор for содержит три части, разделяемые точкой с запятой. Первая часть

fahr  = 0

    выполняется один раз перед входом в сам цикл. Вторая часть проверка, или условие, которое управляет циклом:

 fahr <= 300

    это условие проверяется и, если оно истинно, то выполняется тело цикла (в данном случае только функция printf ). Затем выполняется шаг реинициализации

 fahr =fahr + 20

    и условие проверяется снова. цикл завершается, когда это условие становится ложным. Так же, как и в случае оператора while , тело цикла может состоять из одного оператора или из группы операторов, заключенных в фигурные скобки. Инициализирующая и реинициализирующая части могут быть любыми отдельными выражениями.
    Выбор между операторами while и for произволен и основывается на том , что выглядит яснее. Оператор for обычно удобен для циклов, в которых инициализация и реинициализация логически связаны и каждая задается одним оператором, так как в этом случае запись более компактна, чем при использовании оператора while , а операторы управления циклом сосредотачиваются вместе в одном месте.

    величины lower, upper и step являются константами и поэтому они не указываются в описаниях. Символические имена обычно пишут прописными буквами, чтобы их было легко отличить от написанных строчными буквами имен переменных. отметим, что в конце определения не ставится точка с запятой. Так как подставляется вся строка, следующая за определенным именем, то это привело бы к слишком большому числу точек с запятой в операторе for.

    переменная 'c' содержит следующий символ из входных данных. Символы обычно поступают с терминала, но это не должно нас касаться до главы 7.

    Функция putchar(c) является дополнением к getchar : в результате обращения

         putchar (c)

    Программа, написанная на языке "C", выглядит следующим образом:

  main()  /* copy input to output; 1st version */
  {
     int c;
     c = getchar();
     while (c != EOF) {
            putchar (c);
            c = getchar();
     }
  }

    оператор отношения != означает "не равно". Основная проблема заключается в том, чтобы зафиксировать конец файла ввода. Обычно, когда функция getchar наталкивается на конец файла ввода, она возвращает значение , не являющееся действительным символом; таким образом, программа может установить, что файл ввода исчерпан. Единственное осложнение, являющееся значительным неудобством, заключается в существовании двух общеупотребительных соглашений о том, какое значение фактически является признаком конца файла. Мы отсрочим решение этого вопроса, использовав символическое имя EOF для этого значения, каким бы оно ни было. На практике EOF будет либо -1, либо 0, так что для правильной работы перед программой должно стоять собственно либо

  #define  EOF  -1

    либо

  #define  EOF   0

    использовав символическую константу EOF для представления значения, возвращаемого функцией getchar при выходе на конец файла, мы обеспечили, что только одна величина в программе зависит от конкретного численного значения. Мы также описали переменную 'c' как int , а не char , с тем чтобы она могла хранить значение, возвращаемое getchar . как мы увидим в главе 2, эта величина действительно int, так как она должна быть в состоянии в дополнение ко всем возможным символам представлять и EOF . Программистом, имеющим опыт работы на "C", программа копирования была бы написана более сжато. В языке "C" любое присваивание, такое как

c = getchar()

    может быть использовано в выражении; его значение - просто значение, присваиваемое левой части. Если присваивание символа переменной 'c' поместить внутрь проверочной части оператора while , то программа копирования файла запишется в виде:

main()  /* copy input to output; 2nd version */
 {
 int c;

 while ((c = getchar()) != EOF)
 putchar(c);
 }

    Программа извлекает символ , присваивает его переменной 'c' и затем проверяет, не является ли этот символ признаком конца файла. Если нет - выполняется тело оператора while, выводящее этот символ. Затем цикл while повторяется. когда, наконец, будет достигнут конец файла ввода, оператор while завершается, а вместе с ним заканчивается выполнение и функции main .
    В этой версии централизуется ввод - в программе только одно обращение к функции getchar - и ужимается программа. Вложение присваивания в проверяемое условие - это одно из тех мест языка "C", которое приводит к значительному сокращению программ. Однако, на этом пути можно увлечься и начать писать недоступные для понимания программы. Эту тенденцию мы будем пытаться сдерживать.
    Важно понять , что круглые скобки вокруг присваивания в условном выражении действительно необходимы. Старшинство операции != выше, чем операции присваивания =, а это означает, что в отсутствие круглых скобок проверка условия != будет выполнена до присваивания =. Таким образом, оператор

 c = getchar()  != EOF

    эквивалентен оператору

 c = (getchar() != EOF)

    Это, вопреки нашему желанию, приведет к тому, что 'c' будет принимать значение 0 или 1 в зависимости от того, натолкнется или нет getchar на признак конца файла. Подробнее об этом будет сказано в главе 2.