Введение в c++

C - это язык программирования общего назначения, включающий экономию представления, современное управление потоком и структурой данных и богатый набор операторов. C не является языком "очень высокого уровня", ни "большим" языком, и не предназначена для определенной области применения. Но отсутствие в ней ограничений и ее всеобщность делают ее удобной и эффективной для многих задач, по сравнению с языками, которые считаются более мощными. Изначально, C разработан и воплощен на операционной системе UNIX на DEC PDP-11 Дениса Ричи. Операционная система, компилятор C и, по сути, все программы-приложения UNIX (включая программное обеспечение, используемое для приготовления этой книги) написано на C. Рабочие компиляторы существуют также и для нескольких других машин, включая IBM System/370, Honeywell 6000 и Interdata 8 / 32. Однако, C не привязана к определенному оборудования или системы, и на ней легко писать программы, которые будут работать без изменений на любой машине, поддерживающей C.

Эта статья имеет целью помочь читателю научиться программировать на C. Она включает вводную часть для ознакомления новых пользователей, отдельные разделы, посвященные основным свойствам языка, и справочник. Процесс обучения основывается на чтении, составлении программ и просмотре примеров, вместо простого изложения правил. В большинстве случаев, примеры - это настоящие программы, а не отдельные фрагменты кода. Все примеры проверены непосредственно из текста, который хранится в машинопрочитному виде. Помимо демонстрации того, как эффективно пользоваться языком, мы пытались, где возможно, показать полезные алгоритмы, принципы хорошего стиля и правильной разработки.

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

По нашему опыту, C зарекомендовал себя как приятный, выразительный и разносторонний язык для широкого спектра приложений. Ее легко изучить и она больше подходит, как ваш опыт с ней растет. Мы надеемся, что данная статья поможет вам использовать ее надлежащим образом.

Продуманный критицизм и советы от многочисленных друзей и коллег много добавили к этой книге и нашего удовлетворение ее написания. В частности, Майк Бьянки, Джим Блю, Стю Фельдман, Даг Мак-Илрой, Билл Роом, Боб Рисин и Ларри Рослер, все они тщательно прочитали значительный объем рукописи. Мы также благодарим Эла Ахо, Стива Борну, Дану Двораку, Чаков Харли, Дебби Харли, Мэрион Харрис, Риков Гольт, Стива Джонсона, Джону Меши, Бобовые Митзеви, Ральфом Мусе, Питеру Нельсону, Эллиот Принсону, Биллу Плагеру, Джерри Спивак, Кену Томсону и Питеру Вейнбергер за полезные советы в различных стадиях рукописи, равно как Майку Леско и Джо Оссанни за неоценимую помощь в наборе текста.

Первые шаги

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


Это является первой, важной вехой. Чтобы ее преодолеть, вы должны сначала создать текст программы, компилировать его, загрузить, запустить программу и, наконец, выяснить куда именно поступил вывод. После освоения этих механических деталей, все остальное относительно легко.

В C, программа вывода "hello, world" будет выглядеть так:
# Include

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

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


Если вы нигде не ошиблись, как вот пропустили какой-то знак или допустили орфографической ошибки, процесс компиляции пройдет бесшумно и выдаст исполняемый файл с названием a.out. После того как вы запустите a.out командой
a.out
у вас на экране появится
hello, world

На других системах правила компиляции могут в чем отличаться - спросите местного специалиста.

Теперь - к объяснению самой программы. Программа на языке C, независимо от своего размера, состоит из функций и переменных. Функции включают выражения, указывающие на вычислительные действия, которые будут иметь место, а переменные, в свою очередь, сохраняют значение, используемые во время вычислений. Функции C подобные подпрограмм и функций Fortran или процедур и функций Pascal. В нашем примере, это функция под названием main. Обычно, вы можете предоставлять своим функциям произвольные имена, но "main" - это специальное название. Программа начинает свое выполнение в начале main. Это означает, что каждая программа должна содержать main в каком месте.

Функция main обычно вызывает другие функции для помощи выполнения своей работы, некоторые написаны вами, а некоторые из предоставленных вам библиотек. Первая строка программы,
# Include
указывает компилятору включить информацию о стандартной библиотеке ввода / вывода; эта строка появляется в начале многих исходных текстов C. Стандартная библиотека описана в Разделе 7 и Приложения Б.


Один из способов обмена данными между функциями - это передача викликовою функцией списка значений, называемых аргументами, функции, которую она вызвала. Скобки после имени функции окружают список аргументов. В этом примере, main указано как функцию, которая не ожидает никаких аргументов, что видно из пустого списка в скобках ().
# Include включает информацию о стандартной
библиотеку

main () обозначает функцию с названием main, которая не
получила никаких значений аргументов
{Выражения, принадлежащих main, взято в
фигурные скобки
printf ("hello, world \ n"); main вызывает функцию из стандартной
библиотеки printf для того, чтобы вывести
последовательность знаков
} \ N означает знак новой строки

Первая C-программа

Утверждения, которые относятся функциям, включаются в фигурные скобки. Функция main содержит только одно такое утверждение:
printf ("hello, world \ n");

Функция вызывается указанием ее названия, за которой следует список аргументов в скобках, а значит здесь вызвано функцию printf с аргументом "hello, world \ n". printf - функция библиотеки для печатания вывода, в данном случае - цепочки знаков между лапками.

Последовательность знаков, включенных в двойные кавычки, как "hello, world \ n", называется символьным цепочкой или символьной константой. Пока, единственное место, где мы будем употреблять символьные цепочки, - это в качестве аргумента printf и других функций.

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


printf никогда не добавляет знака новой строки автоматически, что дает возможность использования нескольких вызовов для поэтапного построения вывода. Так, нашу первую программу можно было бы с таким же успехом написать как
# Include

main ()
{
printf ("hello,");
printf ("world");
printf ("\ n");
}
что приведет к тождественного вывода.

Заметьте, что \ n действительности означает только один знак. Экранированные последовательности вроде \ n являются общим механизмом обозначение "трудных для печати" или невидимых символов. Наряду с другими, C также предусматривает \ t для табуляции, \ b для реверса, \ "для вывода двойных кавычек и \ для самой обратной наклонной

Упражнение 1-1. Выполните программу "hello world" вы. Поекпериментуйте с удалением частей программы, чтобы увидеть, какие ошибки при этом возникнут.

Упражнение 1-2. Узнайте, что произойдет, можно использовать аргумент printf последовательность \ c, где c появляться одним из знаков, не упомянутых выше.

Переменные и арифметические выражения

Программа далее использует формулу ° C = (5 / 9) (° F-32) для вывода следующей таблицы температур по Фаренгейту и соответствующих значений по Цельсиусом:
1 -17
20 -6
40 4
60 15
80 26
100 37
120 48
140 60
160 71
180 82
200 93
220 104
240 115
260 126
280 137
300 148


Сама программа все еще состоит из одной только функции main. Она длиннее, чем та, которая выводила "hello world", но не является сложной. Эта программа привносит несколько новых понятий, таких как комментарии, объявления, переменные, арифметические выражения, циклы и форматированный вывод.
# Include

/ * Вывести таблицу Фаренгейт-Цельсиус
с fahr = 0, 20, ..., 300 * /
main ()
{
int fahr, celsius;
int lower, upper, step;

lower = 0; / * нижний предел температурной шкалы * /
upper = 300; / * верхний предел * /
step = 20; / * размер продвижения * /

fahr = lower;
while (fahr <= upper) {
celsius = 5 * (fahr-32) / 9;
printf ("% d \ t% d \ n", fahr, celsius);
fahr = fahr + step;
}
}

Строки
/ * Вывести таблицу Фаренгейт-Цельсиус
с fahr = 0, 20, ..., 300 * /
являются комментарием, который в данном случае кратко объясняет, что именно программа осуществляет. Любые знаки между / * и * / игнорируются компилятором. Комментарии могут свободно использоваться, чтобы сделать программу более понятной. Комментарии можно поместить в любом месте, где могут находиться пробелы, табуляция или знаки новой строки.

В C, все переменные следует объявить до того, как пользоваться ими - как правило, в начале функции, перед выполнением других утверждений. В объявлениях переменных указываются их свойства; каждое объявление состоит из названия типа и списка переменных, вроде
int fahr, celsius;
int lower, upper, step;


Тип int означает, что эти переменные - целые числа, в отличие от float, обозначающий числа с плавающей точкой, то есть числа, которые могут иметь дробную часть. Объем обоих, int и float, зависит от машины; распространенным типом является 16-битные значения int, находящихся в пределах от -32768 до +32768, равно как и 32-битные int. Значение float, как правило, являются 32-битной длины, способной удерживать шестизначные числа в диапазоне между 10-38 и 1038. C предусматривает несколько дополнительных типов данных, кроме int и float, включая char символ - один байт
short короткое целое число
long длинное целое число
double число с плавающей точкой двойной точности


Размер этих данных также является машинозалежним. Кроме этого, существуют еще массивы, структуры и соединения из этих основных типов, указатели на них, а также функции, которые возвращают их. Все это мы пройдем в благоприятный момент.

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


Каждая строка таблицы преобразований вычисляется таким же образом, поэтому мы использовали цикл, повторяющийся по одному разу для каждой строки вывода; именно в этом заключается смысл цикла while
while (fahr <= upper) {
...
}

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

Тело цикла while может состоять из одного или более утверждений, включенных в фигурные скобки, как в программе преобразования температур, либо только одного утверждения без фигурных скобок, как например
while (i i = 2 * i;


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

Больше работы осуществляется в теле цикла. Температура за Цельсиусом исчисляется и сохраняется в переменной celsius выражением
celsius = 5 * (fahr-32) / 9;

Причиной умножения на пять затем деления на 9 вместо просто умножение на 5 / 9 является то, что C, как и многие другие языки, пожимает результат деления целых чисел - дробная часть отбрасывается. Поскольку 5 и 9 - оба целые числа, деление 5 / 9 округлится до нуля, поэтому все температуры по Цельсиусу отчитываться как нулевые.

Этот пример программы также раскрывает нам немного больше о работе printf. printf является функцией общего назначения для форматированного вывода (мы ее опишем подробнее в разделе 7). Ее первым аргументом является цепочка знаков, будет выведено, где% указывает те части, которые будут заменены, и в какой форме произойдет вывод. Так например,% d указывает на десятичный аргумент, поэтому выражение
printf ("% d \ t% d \ n", fahr, celsius);


выведет значения двух целых fahr и celsius, разделенные табуляцией (\ t).

Каждая конструкция с% первого (включенного в кавычки) аргумента printf, находит себе пару во втором, третьем, и так далее, аргументу printf, они должны совпасть количественно и по типу, иначе вы получите ложные ответы.

Между прочим, printf не является частью языка C, ввод и вывод не определено в самом языке. printf - это функция среди других функций стандартной библиотеки языка. Однако, поведение printf описано стандартом ANSI, поэтому оно должно быть одинаковым, независимо от компилятора и платформы, которые используются.

Для того, чтобы сосредоточиться на самой C, мы не будем обсуждать ввод и вывод значительной мере вплоть до раздела 7. В частности, мы удержимся к тому времени от форматированного ввода. Если вам надо написать что-то с вводом чисел, загляните к обсуждению функции scanf в Разделе 7.4. Последнее похожа на printf, за исключением того, что scanf читает ввод, вместо осуществлять вывод.

Наша программа преобразования температуры имеет однако несколько недостатков. Простейшая из них это то, что вывод - недостаточно привлекателен, поскольку числа не выровнены с правой стороны. Это легко исправить, если добавить к каждому утверждение% d функции printf аргумент ширины. В этом случае, числа будет выровнен вправо. Так, например, мы можем сказать
printf ("% 3d% 6d \ n", fahr, celsius);

чтобы вывести первое число каждой строки шириной в три знака, а второе число - шириной в шесть:
0 -17
20 -6
40 4
60 15
80 26
100 37
...


Более серьезная проблема заключается в том, что мы использовали арифметику десятичных чисел, поэтому полученная температура по Цельсиусу - недостаточно точна. Например, 0F, в действительности равно-17.8C, а не -17. Чтобы получить более точные ответы, мы должны обратиться к арифметике чисел с плавающей точкой вместо целых. Это требует некоторых изменений в программе. Вот вторая версия:
# Include

/ * Выводит таблицу Фаренгейт-Цельсиус с fahr = 0, 20, ..., 300;
версия с числами с плавающей точкой * /
main ()
{
float fahr, celsius;
float lower, upper, step;

lower = 0; / * нижний предел температурной шкалы * /
upper = 300; / * верхний предел * /
step = 20; / * размер шага * /

fahr = lower;
while (fahr <= upper) {
celsius = (5.0/9.0) * (fahr-32.0);
printf ("% 3.0f% 6.1f \ n", fahr, celsius);
fahr = fahr + step;

}
}

Этот вариант очень похож на предыдущий, за исключением того, что fahr и celsius объявлен как float, а саму формулу преобразования написано в натуральнее образом. Мы не могли использовать 5 / 9 в предыдущей программе, поскольку деление целых округлилося бы к нулю. Десятичная точка в константе указывает на то, что это является числом с плавающей точкой, поэтому 5.0/9.0 НЕ округляется.

Если арифметический оператор только целые операнды, состоится действие с целыми. Если же арифметический оператор имеет один операнд, является числом с плавающей точкой, и один операнд-целое, тогда целое будет преобразован в число с плавающей точкой. Поэтому, если бы мы написали (fahr-32), 32 автоматически превратилось бы в дробь. Тем не менее, написание констант с десятичной частью подчеркивает для читателей кода тот факт, что они имеют дело с числами с десятичной точкой.

Вы найдете подробное описание того, когда цели превращаются в числа с плавающей точкой в ​​главе 2. Пока заметьте, что присвоение
fahr = lower;
и тестирование
while (fahr <= upper)
также работают в натуральный способ - int преобразовано в float перед тем как совершить сделку.


Указатель преобразования% 3.0f функции printf означает, что нужно вывести число с плавающей точкой (здесь fahr), шириной не менее трех знаки, без десятичной точки и дробной части. % 6.1f описывает другое число (celsius), которое будет выведено как минимум шириной шесть знаков, с одной цифрой после десятичного знака. Вывод будет выглядеть следующим образом:
0 -17.8
20 -6.7
40 4.4
...

Ширина и точность может быть опущенной в определителю:% 6f означает, что число должно быть, по крайней мере, шириной шесть знаков,% .2 f указывает на два знака после запятой, но без ограничения ширины, а% f - просто вывод числа с подвижной точкой. % D вывести как десятичное целое
% 6d вывести как десятичное целое шириной как минимум 6 знаков
% F вывести как число с плавающей точкой
% 6f вывести как число с плавающей точкой шириной как минимум 6 знаков
% .2 F вывести как число с плавающей точкой с двумя знаками после запятой
% 6.2f вывести как число с плавающей точкой шириной как минимум 6 знаков с вторым после запятой


Среди прочих, printf также распознает% o для восьмеричного,% x - для шестнадцатеричного,% c - для символа,% s - для символьного цепочки, и%% - для отображения самого%.

Утверждение for

Существует много способов написания программы для решения одной и той же задачи. Поэтому, попробуем другой вариант преобразователя температур.
# Include

/ * Выводит таблицу Фаренгейт-Цельсиус * /
main ()
{
int fahr;

for (fahr = 0; fahr <= 300; fahr = fahr + 20)
printf ("% 3d% 6.1f \ n", fahr, (5.0/9.0) * (fahr-32));
}

Это приводит те же ответы, но, несомненно, выглядит иначе. Одна из основных перемен - это удаление большинства переменных осталась только fahr, и мы объявили ее как int. Верхняя и нижняя граница и шаг представлены как константы в утверждении for, - новой для нас конструкции. Выражение, вычисляет температуру по Цельсиусу, появляется как третий аргумент printf, вместо отдельного выражения присвоения.

Это последнее изменение является примером общего правила - в любом контексте, где употребляется значение определенного типа, вы можете использовать сложный выражение того же типа. Поскольку Третьим аргументом printf должно быть число с плавающей точкой, чтобы сойтись с% 6.1f, то любое выражение, которое возвращает число с плавающей точкой, может занять это место.

Утверждение for также является циклом - обобщенным случаем while. Если вы сравните его с предыдущим while, то работа for станет понятной. Внутри скобок существуют три части, разделенные точкой с запятой. Первая часть, инициализация
fahr = 0
происходит один раз, еще до того, как войти в цикл. Вторая часть - это проверка условия, контролирующая цикл:
fahr <= 300
Это условие вычисляется; если она истинна, будет выполнен корпус цикла (в этом случае одно выражение printf). После этого выполняется стадия прироста
fahr = fahr + 20
и условие оценивается снова. Цикл завершится только тогда, когда условие окажется ошибочной. Так же как и с while, корпус цикла может содержать одно утверждение или группу утверждений, включенных в фигурные скобки. Инициализацией, условием и приростом может служить любое выражение.

Выбор между while и for является произвольным и зависит только от того, какой из них кажется понятным. for, как правило, подходит для циклов, в которых инициализация и прирост состоят из одного выражения каждый, и они логически связаны между собой. Это компактнее по while, и сохраняет выражения, которые контролируют цикл, вместе, в одном месте.

Символические константы

Последнее наблюдение, до того как мы навсегда оставим программу преобразования температур. Считается плохой практикой закапывать "магические числа", такие как 300 и 20 где-то внутри программы, они мало о чем говорят тем, кто пересматривает программу позже, и их трудно изменить в систематический способ. Одним из решений вопроса о "магические числа" является предоставление им осмысленных имен. Рядок # define обозначает символическое название или символическую константу для цепочки каких знаков:
# Define название замена


Таким образом, любое появление названия (не в кавычках, и не как часть другого названия) будет заменен на соответствующий текст замены. Название имеет ту же форму, что и название переменных: последовательность букв и цифр, начинающихся с буквы. Текст замены может состоять из произвольной последовательности знаков, он не ограничен только числами.
# Include

# Define LOWER 0 / * нижний предел температурной шкалы * /
# Define UPPER 300 / * верхний предел * /
# Define STEP 20 / * размер шага * /

/ * Выводит таблицу Фаренгейт-Цельсиус * /
main ()
{
int fahr;

for (fahr = LOWER; fahr <= UPPER; fahr = fahr + STEP)
printf ("% 3d% 6.1f \ n", fahr, (5.0/9.0) * (fahr-32));

}

Величины LOWER, UPPER и STEP - это символические константы, а не переменные, поэтому они не появляются в объявлениях. Названия символических постоянных традиционно пишутся с больших букв, чтобы легко было отличить их от названий переменных в нижнем регистре. Обратите внимание, что точки с запятой нет в конце строки # define.

Ввод и вывод знаков

Мы рассмотрим группу родственных программ для проработки символьных данных. Вы поймете позже, что многие программы - это просто расширенные версии прототипов, которые мы будем обсуждать здесь.

Модель ввода и вывода, поддерживаемая стандартной библиотекой, - довольно простая. Текстовый ввод или вывод, независимо от того откуда он происходит или куда направляются, рассматривается как поток знаков. Текстовый поток - это последовательность знаков, разделенных на строки, где каждая строка состоит из нуля или более символов с последующим знаком новой строки. Это остается ответственностью библиотеки - добиться того, чтобы каждый поток ввода или вывода отвечал этой модели. C-программист не должен беспокоиться тем, как представлены строки вне программы.

Стандартная библиотека предусматривает несколько функций чтения по одному знаку за раз, из которых getchar и putchar являются простейшими. Каждый раз как она вызвана, getchar считывает следующий вводимый символ из текстового потока и возвращает этот знак как собственное значение. То есть, после
c = getchar ();
переменная c содержать следующий знак ввода. Знаки, как правило, поступают с клавиатуры; ввод из файлов мы обсудим в Разделе 7.


Функция putchar выводит один знак каждый раз как она вызвана:
putchar (c);
выводит как знак содержание целочисленной переменной c; типично вывод поступает на экран. Вызовы putchar и printf можно чередовать; вывод появляться в той последовательности, в которой осуществлен вызовы.

Копирование файла

Имея getchar и putchar вы можете написать удивительную количество полезного кода, не зная больше ничего о ввод и вывод. Простейший пример - это программа, копирующая свой ввод до собственного вывода по одному знаку за раз:

распознать знак
while (знак не является указателем конца файла)
вывести только что прочитанный знак
прочитать следующий знак


Перевод в C даст нам:
# Include

/ * Копирует ввод к выводу; первый версия * /
main ()
{
int c;

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

Сравнительный оператор! = Означает "не равно".

То, что кажется знаком на клавиатуре или экране, конечно как и все остальное, сохраняется внутренне, как последовательность битов. Тип char специально предназначенный для хранения таких знаковых данных, хотя для этого можно использовать любой тип целого. Мы воспользовались int из тонких но важных соображений.

Проблема заключается в отделении конца ввода от действующих данных. Решение ее связано с фактом, что getchar возвращает отличное значение, когда нет больше ввода - значение, которое нельзя путать с каким действительным знаком. Оно называется EOF, что происходит от "end of file". Мы должны объявить c такого типа, который был достаточно большим для сохранения любого значения, возвращенного getchar. Мы не можем воспользоваться char, поскольку c должна быть достаточно вместительной, чтобы удержать EOF, кроме обычных символов. Именно поэтому, мы прибегли к int.

EOF - это целое, определенное в . Его типичная величина не столь важна, пока она не совпадает со значением какого знака. Используя символическую константу EOF, мы также убеждаемся, что ничего в программе не зависит от определенного числового значения.

У опытных программистов, программа копирования выглядеть короче. В языке C, любое присвоение вроде
c = getchar ();
является выражением и неважно, что равно значению слева после присвоения. Это означает, что присвоение может появляться как часть большего выражения. Если присвоение символа переменной c поместить в тестовую часть цикла while, программу копирования можно написать так:
# Include

/ * Копирует ввод к выводу, 2-я версия * /
main ()
{
int c;

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


Цикл while добывает символ, присваивает его c, затем проверяет, этот символ не был указателем конца файла. Если нет, выполняется корпус while, выводя символ. После этого while повторяется. По достижению конца ввода, while завершится; так же main.

Эта версия централизует ввод - существует только одна ссылка на getchar, и это делает программу более сжатые. Полученная в результате программа, компактнее и, как только вы овладеете идиомой, легче читается. Вы часто встретите этот стиль. (Существует однако опасность увлечься и создать непроницаемый для понимания код; мы постараемся избегать этой тенденции.)

Скобки вокруг присвоения внутри условия обязательны. ! = Имеет больший приоритет по =, что означает, что при отсутствии скобок сравнительная проверка! = Состоялась бы к присвоению. Так, выражение
c = getchar ()! = EOF
равнозначен
c = (getchar ()! = EOF)

Последнее приводит к нежелательному эффекту присвоении c значений 0 или 1 в зависимости от того, возвратил вызов getchar конец файла или нет.