WWW.DISSERS.RU

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ БИБЛИОТЕКА

   Добро пожаловать!

Pages:     || 2 | 3 | 4 |
-- [ Страница 1 ] --

Б.В. Керниган, Д.М. Ричи.

ЯЗЫК С Аннотация Язык "C"(произносится "си") — это универсальный язык программирования, для которого характерны экономичность выражения, современный поток управления и структуры данных, богатый набор операторов. Язык "C" не является ни языком "очень высокого уровня", ни "большим" языком, и не предназначается для некоторой специальной области применения. но отсутствие ограничений и общность языка делают его более удобным и эффективным для многих задач, чем языки, предположительно более мощные.

Язык "C", первоначально предназначавшийся для написания операционной системы "UNIX" на ЭВМ DEC PDP-11, был разработан и реализован на этой системе Деннисом Ричи. Операционная система, компилятор с языка "C" и по существу все прикладные программы системы "UNIX" (включая все программное обеспечение, использованное при подготовке этой книги) написаны на "C". Коммерческие компиляторы с языка "C" существуют также на некоторых других ЭВМ, включая IBM SYSTEM/370, HONEYWELL 6000, INTERDATA 8/32. Язык "C", однако, не связан с какими-либо определенными аппаратными средствами или системами, ина немлегко писать программы, которые можно пропускать без изменений на любой ЭВМ, имеющей "C"-компилятор.

Эта книга предназначена для того, чтобы помочь читателю научиться программировать на языке "C". Она содержит учебное введение, цель которого — позволить новым пользователям начать программировать как можно быстрее, отдельные главы по всем основным особенностям языка и справочное руководство.

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

Настоящая книга не является вводным курсом в программирование;

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

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

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

Брайен В. Керниган Деннис М. Ричи Содержание ВВЕДЕНИЕ 1. УЧЕБНОЕ ВВЕДЕНИЕ 1.1. HАЧИНАЕМ 1.2. ПЕРЕМЕННЫЕ И АРИФМЕТИКА 1.3. ОПЕРАТОР FOR 1.4. СИМВОЛИЧЕСКИЕ КОНСТАНТЫ 1.5. НАБОР ПОЛЕЗНЫХ ПРОГРАММ 1.5.1. ВВОД И ВЫВОД СИМВОЛОВ 1.5.2. КОПИРОВАНИЕ ФАЙЛА 1.5.3. ПОДСЧЕТ СИМВОЛОВ 1.5.4. ПОДСЧЕТ СТРОК 1.5.5. ПОДСЧЕТ СЛОВ 1.6. МАССИВЫ 1.7. ФУНКЦИИ 1.8. АРГУМЕНТЫ — ВЫЗОВ ПО ЗНАЧЕНИЮ 1.9. МАССИВЫ СИМВОЛОВ 1.10. ОБЛАСТЬ ДЕЙСТВИЯ: ВНЕШНИЕ ПЕРЕМЕННЫЕ 2. ТИПЫ, ОПЕРАЦИИ И ВЫРАЖЕНИЯ 2.1. ИМЕНА ПЕРЕМЕННЫХ 2.2. ТИПЫ И РАЗМЕРЫ ДАННЫХ 2.3. КОНСТАНТЫ 2.3.1. СИМВОЛЬНАЯ КОНСТАНТА 2.3.2. КОНСТАНТНОЕ ВЫРАЖЕНИЕ 2.3.3. СТРОЧНАЯ КОНСТАНТА 2.4. ОПИСАНИЯ 2.5. АРИФМЕТИЧЕСКИЕ ОПЕРАЦИИ 2.6. ОПЕРАЦИИ ОТНОШЕНИЯ И ЛОГИЧЕСКИЕ ОПЕРАЦИИ 2.7. ПРЕОБРАЗОВАНИЕ ТИПОВ 2.8. ОПЕРАЦИИ УВЕЛИЧЕНИЯ И УМЕНЬШЕНИЯ 2.9. ПОБИТОВЫЕ ЛОГИЧЕСКИЕ ОПЕРАЦИИ 2.10. ОПЕРАЦИИ И ВЫРАЖЕНИЯ ПРИСВАИВАНИЯ 2.11. УСЛОВНЫЕ ВЫРАЖЕНИЯ 2.12. СТАРШИНСТВО И ПОРЯДОК ВЫЧИСЛЕНИЯ 3. ПОТОК УПРАВЛЕНИЯ 3.1. ОПЕРАТОРЫ И БЛОКИ 3.2. IF — ELSE 3.3. ELSE — IF 3.4. ПЕРЕКЛЮЧАТЕЛЬ 3.5. ЦИКЛЫ —WHILEИ FOR 3.7. ОПЕРАТОР BREAK 3.8. ОПЕРАТОР CONTINUE 3.9. ОПЕРАТОР GOTO ИМЕТКИ 4. ФУНКЦИИ И СТРУКТУРА ПРОГРАММ 4.1. ОСНОВНЫЕ СВЕДЕНИЯ 4.2. ФУНКЦИИ, ВОЗВРАЩАЮЩИЕ НЕЦЕЛЫЕ ЗНАЧЕНИЯ 4.3. ЕЩЕ ОБ АРГУМЕНТАХ ФУНКЦИЙ 4.4. ВНЕШНИЕ ПЕРЕМЕННЫЕ 4.5. ПРАВИЛА, ОПРЕДЕЛЯЮЩИЕ ОБЛАСТЬ ДЕЙСТВИЯ 4.5.1. ОБЛАСТЬ ДЕЙСТВИЯ 4.6. СТАТИЧЕСКИЕ ПЕРЕМЕННЫЕ 4.7. РЕГИСТРОВЫЕ ПЕРЕМЕННЫЕ 4.8. БЛОЧНАЯ СТРУКТУРА 4.9. ИНИЦИАЛИЗАЦИЯ 4.10. РЕКУРСИЯ 4.11. ПРЕПРОЦЕССОР ЯЗЫКА "C" 4.11.1. ВКЛЮЧЕНИЕ ФАЙЛОВ 4.11.2. МАКРОПОДСТАНОВКА 5.УКАЗАТЕЛИ И МАССИВЫ 5.1. УКАЗАТЕЛИИАДРЕСА 5.2. УКАЗАТЕЛИ И АРГУМЕНТЫ ФУНКЦИЙ 5.3. УКАЗАТЕЛИ И МАССИВЫ 5.4. АДРЕСНАЯ АРИФМЕТИКА 5.5. УКАЗАТЕЛИ СИМВОЛОВ И ФУНКЦИИ 5.6. УКАЗАТЕЛИ — НЕ ЦЕЛЫЕ 5.7. МНОГОМЕРНЫЕ МАССИВЫ 5.8. МАССИВЫ УКАЗАТЕЛЕЙ;

УКАЗАТЕЛИ УКАЗАТЕЛЕЙ 5.9. ИНИЦИАЛИЗАЦИЯ МАССИВОВ УКАЗАТЕЛЕЙ 5.10. УКАЗАТЕЛИ И МНОГОМЕРНЫЕ МАССИВЫ 5.11. КОМАНДНАЯ СТРОКА АРГУМЕНТОВ 5.12. УКАЗАТЕЛИ НА ФУНКЦИИ 6. СТРУКТУРЫ 6.1. ОСНОВНЫЕ СВЕДЕНИЯ 6.2. СТРУКТУРЫ И ФУНКЦИИ 6.3. МАССИВЫ СТРУКТУР 6.4. УКАЗАТЕЛИ НА СТРУКТУРЫ 6.5. СТРУКТУРЫ, ССЫЛАЮЩИЕСЯ НА СЕБЯ. 6.6. ПОИСК В ТАБЛИЦЕ 6.7. ПОЛЯ 6.8. ОБЪЕДИНЕНИЯ 6.9. ОПРЕДЕЛЕНИЕ ТИПА 7. ВВОД И ВЫВОД 7.1. ОБРАЩЕНИЕ К СТАНДАРТНОЙ БИБЛИОТЕКЕ 7.2. СТАНДАРТНЫЙ ВВОД И ВЫВОД — ФУНКЦИИ GETCHAR И PUTCHAR 7.3. ФОРМАТНЫЙ ВЫВОД — ФУНКЦИЯ PRINTF 7.4. ФОРМАТНЫЙ ВВОД — ФУНКЦИЯ SCANF 7.5. ФОРМАТНОЕ ПРЕОБРАЗОВАНИЕ В ПАМЯТИ 7.6. ДОСТУП К ФАЙЛАМ 7.7. ОБРАБОТКА ОШИБОК — STDERR И EXIT 7.8. ВВОД И ВЫВОД СТРОК 7.9. НЕСКОЛЬКО РАЗНООБРАЗНЫХ ФУНКЦИЙ 7.9.1. ПРОВЕРКА ВИДА СИМВОЛОВ И ПРЕОБРАЗОВАНИЯ 7.9.2. ФУНКЦИЯ UNGETC 7.9.3. ОБРАЩЕНИЕ К СИСТЕМЕ 7.9.4. УПРАВЛЕНИЕ ПАМЯТЬЮ 8. ИНТЕРФЕЙС СИСТЕМЫ UNIX 8.1. ДЕСКРИПТОРЫ ФАЙЛОВ 8.2. НИЗКОУРОВНЕВЫЙ ВВОД/ВЫВОД — ОПЕРАТОРЫ READ И WRITE 8.3. ОТКРЫТИЕ, СОЗДАНИЕ, ЗАКРЫТИЕ И РАСЦЕПЛЕНИЕ (UNLINK) 8.4. ПРОИЗВОЛЬНЫЙ ДОСТУП — SEEK И LSEEK 8.5. ПРИМЕР — РЕАЛИЗАЦИЯ ФУНКЦИЙ FOPEN И GETC 8.6. ПРИМЕР — РАСПЕЧАТКА СПРАВОЧНИКОВ 8.7. ПРИМЕР — РАСПРЕДЕЛИТЕЛЬ ПАМЯТИ 9. ПРИЛОЖЕНИЕ А: СПРАВОЧНОЕ РУКОВОДСТВО ПО ЯЗЫКУ 'C' 9.1. ВВЕДЕНИЕ 10. ЛЕКСИЧЕСКИЕ СОГЛАШЕНИЯ 10.1. КОММЕНТАРИИ 10.2. ИДЕНТИФИКАТОРЫ (ИМЕНА) 10.3. КЛЮЧЕВЫЕ СЛОВА 10.4. КОНСТАНТЫ 10.4.1. ЦЕЛЫЕ КОНСТАНТЫ 10.4.2. ЯВНЫЕ ДЛИННЫЕ КОНСТАНТЫ 10.4.3. СИМВОЛЬНЫЕ КОНСТАНТЫ 10.4.4. ПЛАВАЮЩИЕ КОНСТАНТЫ 10.5. СТРОКИ 10.6. ХАРАКТЕРИСТИКИ АППАРАТНЫХ СРЕДСТВ 11. СИНТАКСИЧЕСКАЯ НОТАЦИЯ 12. ЧТО В ИМЕНЕ ТЕБЕ МОЕМ? 13. ОБЪЕКТЫ И L-ЗНАЧЕНИЯ 14. ПРЕОБРАЗОВАНИЯ 14.1. СИМВОЛЫ И ЦЕЛЫЕ 14.2. ТИПЫ FLOAT И DOUBLE 14.3. ПЛАВАЮЩИЕ И ЦЕЛОЧИСЛЕННЫЕ ВЕЛИЧИНЫ 14.4. УКАЗАТЕЛИ И ЦЕЛЫЕ 14.5. ЦЕЛОЕ БЕЗ ЗНАКА 14.6. АРИФМЕТИЧЕСКИЕ ПРЕОБРАЗОВАНИЯ 15. ВЫРАЖЕНИЯ 15.1. ПЕРВИЧНЫЕ ВЫРАЖЕНИЯ 15.2. УНАРНЫЕ ОПЕРАЦИИ 15.3. МУЛЬТИПЛИКАТИВНЫЕ ОПЕРАЦИИ 15.4. АДДИТИВНЫЕ ОПЕРАЦИИ 15.5. ОПЕРАЦИИ СДВИГА 15.6. ОПЕРАЦИИ ОТНОШЕНИЯ 15.7. ОПЕРАЦИИ РАВЕНСТВА 15.8. ПОБИТОВАЯ ОПЕРАЦИЯ 'И' 15.9. ПОБИТОВАЯ ОПЕРАЦИЯ ИСКЛЮЧАЮЩЕГО 'ИЛИ' 15.10. ПОБИТОВАЯ ОПЕРАЦИЯ ВКЛЮЧАЮЩЕГО 'ИЛИ' 15.11. ЛОГИЧЕСКАЯ ОПЕРАЦИЯ 'И' 15.12. ОПЕРАЦИЯ ЛОГИЧЕСКОГО 'ИЛИ' 15.13. УСЛОВНАЯ ОПЕРАЦИЯ 15.14. ОПЕРАЦИЯ ПРИСВАИВАНИЯ 15.15. ОПЕРАЦИЯ ЗАПЯТАЯ 16. ОПИСАНИЯ 16.1. СПЕЦИФИКАТОРЫ КЛАССА ПАМЯТИ 16.2. СПЕЦИФИКАТОРЫ ТИПА 16.3. ОПИСАТЕЛИ 16.4. СМЫСЛ ОПИСАТЕЛЕЙ 16.5. ОПИСАНИЕ СТРУКТУР И ОБЪЕДИНЕНИЙ 16.6. ИНИЦИАЛИЗАЦИЯ 16.7. ИМЕНА ТИПОВ 16.8. TYPEDEF 17. ОПЕРАТОРЫ 17.1. ОПЕРАТОРНОЕ ВЫРАЖЕНИЕ 17.2. СОСТАВНОЙ ОПЕРАТОР (ИЛИ БЛОК) 17.3. УСЛОВНЫЕ ОПЕРАТОРЫ 17.4. ОПЕРАТОР WHILE 17.5. ОПЕРАТОР DO 17.6. ОПЕРАТОР FOR 17.7. ОПЕРАТОР SWITCH 17.8. ОПЕРАТОР BREAK 17.9. ОПЕРАТОР CONTINUE 17.10. ОПЕРАТОР ВОЗВРАТА 17.11. ОПЕРАТОР GOTO 17.12. ПОМЕЧЕННЫЙ ОПЕРАТОР 17.13. ПУСТОЙ ОПЕРАТОР 18. ВНЕШНИЕ ОПРЕДЕЛЕНИЯ 18.1. ВНЕШНЕЕ ОПРЕДЕЛЕНИЕ ФУНКЦИИ 18.2. ВНЕШНИЕ ОПРЕДЕЛЕНИЯ ДАННЫХ 19. ПРАВИЛА, ОПРЕДЕЛЯЮЩИЕ ОБЛАСТЬ ДЕЙСТВИЯ 19.1. ЛЕКСИЧЕСКАЯ ОБЛАСТЬ ДЕЙСТВИЯ 19.2. ОБЛАСТЬ ДЕЙСТВИЯ ВНЕШНИХ ИДЕНТИФИКАТОРОВ 20. СТРОКИ УПРАВЛЕНИЯ КОМПИЛЯТОРОМ 20.1. ЗАМЕНА ЛЕКСЕМ 20.2. ВКЛЮЧЕНИЕ ФАЙЛОВ 20.3. УСЛОВНАЯ КОМПИЛЯЦИЯ 21. НЕЯВНЫЕ ОПИСАНИЯ 22. СНОВА О ТИПАХ 22.1. СТРУКТУРЫ И ОБЪЕДИНЕНИЯ 22.2. ФУНКЦИИ 22.3. МАССИВЫ, УКАЗАТЕЛИ И ИНДЕКСАЦИЯ 22.4. ЯВНЫЕ ПРЕОБРАЗОВАНИЯ УКАЗАТЕЛЕЙ 23. КОНСТАНТНЫЕ ВЫРАЖЕНИЯ 24. СООБРАЖЕНИЯ О ПЕРЕНОСИМОСТИ 25. АНАХРОНИЗМЫ 26. СВОДКА СИНТАКСИЧЕСКИХ ПРАВИЛ 26.1. ВЫРАЖЕНИЯ 26.2. ОПИСАНИЯ 27. ПРИСВАИВАНИЕ СТРУКТУРЫ 28. ТИП ПЕРЕЧИСЛЕНИЯ 29. ТАБЛИЦА ИЗОБРАЖЕНИЙ НЕПЕЧАТНЫХ СИМВОЛОВ ЯЗЫКА "C". Б.В. Керниган, Д.М. Ричи. Язык С.

Введение Язык "C" является универсальным языком программирования. Он тесно связан с операционной системой "UNIX", так как был развит на этой системе и так как "UNIX" и ее программное обеспечение написано на "C". Сам язык, однако, не связан с какой-либо одной операционной системой или машиной;

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

Язык "C" — это язык относительно "низкого уровня". В такой характеристике нет ничего оскорбительного;

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

В языке "C" отсутствуют операции, имеющие дело непосредственно с составными объектами, такими как строки символов, множества, списки или с массивами, рассматриваемыми как целое. Здесь, например, нет никакого аналога операциям PL/1, оперирующим с целыми массивами и строками. Язык не предос тавляет никаких других возможностей распределения памяти, кроме статического определения и механизма стеков, обеспечиваемого локальными переменных функций;

здесь нет ни "куч"(HEAP), ни "сборки мусора", как это предусматривается в АЛГОЛЕ 68. Наконец, сам по себе "C" не обеспечивает никаких возможностей ввода-вывода:

здесь нет операторов READ или WRITE и никаких встроенных методов доступа к файлам. Все эти механизмы высокого уровня должны обеспечиваться явно вызыва емыми функциями.

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

Хотя отсутствие некоторых из этих средств может выглядеть как удручающая неполноценность ("выходит, что я должен обращаться к функции, чтобы сравнить две строки символов?!"), но удержание языка в скромных размерах дает реальные преимущества. Так как "C" относительно мал, он не требует много места для своего описания и может быть быстро выучен. Компилятор с "C" может быть простым и компактным. Кроме того, компиляторы легко пишутся;

при использовании современной технологии можно ожидать написания компилятора для новой ЭВМ за пару месяцев и при этом окажется, что 80 процентов программы нового компилятора будет общей с программой для уже существующих компиляторов. Это обеспечивает высокую степень мобильности языка. Поскольку типы данных и стуктуры управле ния, имеющиеся в "C", непосредственно поддерживаются большинством существующих ЭВМ, библиотека, необходимая во время прогона изолированных программ, оказывается очень маленькой. На PDP -11, например, она содержит только программы для 32-битового умножения и деления и для выполнения программ ввода и вывода последовательностей. Конечно, каждая реализация обеспечивает исчерпывающую, совместимую библиотеку функций для выполнения операций ввода-вывода, обработки строк и распределения памяти, но так как обращение к ним осуществляется только явно, можно, если необходимо, избежать их вызова;

эти функции могут быть компактно написаны на самом "C".

Опять же из-за того, что язык "C" отражает возможности современных компьютеров, программы на "C" оказываются достаточно эффективными, так что не Б.В. Керниган, Д.М. Ричи. Язык С.

возникает побуждения писать вместо этого программы на языке ассемблера.

Наиболее убедительным примером этого является сама операционная система "UNIX", которая почти полностью написана на "C". Из 13000 строк программы системы только около 800 строк самого низкого уровня написаны на ассемблере. Кроме того, по существу все прикладное программное обеспечение системы "UNIX" написано на "C";

подавляющее большинство пользователей системы "UNIX"(включая одного из авторов этой книги) даже не знает языка ассемблера PDP-11.

Хотя "C" соответствует возможностям многих ЭВМ, он не зависит от какой-либо конкретной архитектуры машины и в силу этого без особых усилий позволяет писать "переносимые" программы, т.е. программы, которые можно пропускать без измене ний на различных аппаратных средствах. В наших кругах стал уже традицией перенос программного обеспечения, разработанного на системе "UNIX", на системы ЭВМ: HONEYWELL, IBM и INTERDATA. Фактически компиляторы с "C" и программное обеспечение во время прогона программ на этих четырех системах, по-видимому, гораздо более совместимы, чем стандартные версии фортрана американского национального института стандартов (ANSI). Сама операционная система "UNIX" теперь работает как на PDP-11, так и на INTERDATA 8/32. За исключением программ, которые неизбежно оказываются в некоторой степени машинно-зависимыми, таких как компилятор, ассемблер и отладчик. Написанное на языке "C" программное обеспечение идентично на обеих машинах. Внутри самой операционной системы 7000 строк программы, исключая математическое обеспечение языка ассемблера ЭВМ и управления операциями ввода-вывода, совпадают на 95 процентов.

Программистам, знакомым с другими языками, для сравнения и противопоставления может оказаться полезным упоминание нескольких исторических, технических и философских аспектов "C".

Многие из наиболее важных идей "C" происходят от гораздо более старого, но все еще вполне жизненного языка BCPL, разработанного Мартином Ричардсом.

Косвенно язык BCPL оказал влияние на "C" через язык "B", написанный Кеном Томпсоном в 1970 году для первой операционной системы "UNIX" на ЭВМ PDP-7.

Хотя язык "C" имеет несколько общих с BCPL характерных особенностей, он никоим образом не является диалектом последнего. И BCPL и "B" — "безтипные" языки;

единственным видом данных для них являются машинное слово, а доступ к другим объектам реализуется специальными операторами или обращением к функциям. В языке "C" объектами основных типов данных являются символы, целые числа нескольких размеров и числа с плавающей точкой. Кроме того, имеется иерархия производных типов данных, создаваемых указателями, массивами, структурами, объединениями и функциями.

Язык "C" включает основные конструкции потока управления, требуемые для хорошо структуированных программ: группирование операторов, принятие решений (IF), циклы с проверкой завершения в начале (WHILE, FOR) или в конце (DO) и выбор одного из множества возможных вариантов (SWITCH). (Все эти возможности обеспечивались и в BCPL, хотя и при несколько отличном синтаксисе;

этот язык предчувствовал наступившую через несколько лет моду на структурное программирование).

В языке "C" имеются указатели и возможность адресной арифметики.

Аргументы передаются функциям посредством копирования значения аргумента, и вызванная функция не может изменить фактический аргумент в вызывающей программе. Если желательно добиться "вызова по ссылке", можно неявно передать указатель, и функция сможет изменить объект, на который этот указатель указывает.

Имена массивов передаются указанием начала массивов, так что аргументы типа массивов эффективно вызываются по ссылке.

Б.В. Керниган, Д.М. Ричи. Язык С.

К любой функции можно обращаться рекурсивно, и ее локальные переменные обычно "автоматические", т.е. Создаются заново при каждом обращении. Описание одной функции не может содержаться внутри другой, но переменные могут описываться в соответствии с обычной блочной структурой. Функции в "C" — программе могут транслироваться отдельно. переменные по отношению к функции могут быть внутренними, внешними, но известными только в пределах одного исходного файла, или полностью глобальными. Внутренние переменные могут быть автоматическими или статическими. Автоматические переменные для большей эффективности можно помещать в регистры, но объявление регистра является только указанием для компилятора и никак не связано с конкретными машинными регистрами.

Язык "C" не является языком со строгими типами в смысле паскаля или алгола 68. Он сравнительно снисходителен к преобразованию данных, хотя и не будет автоматически преобразовывать типы данных с буйной непринужденностью языка PL/1. Существующие компиляторы не предусматривают никакой проверки во время выполнения программы индексов массивов, типов аргументов и т.д.

В тех ситуациях, когда желательна строгая проверка типов, используется специальная версия компилятора. Эта программа называется LINT очевидно потому, она выбирает кусочки пуха из вашей программы. Программа LINT не генерирует машинного кода, а делает очень строгую проверку всех тех сторон программы, которые можно проконтролировать во время компиляции и загрузки. Она определяет несоответствие типов, несовместимость аргументов, неиспользованные или очевидным образом неинициализированные переменные, потенциальные трудности переносимости и т.д. Для программ,которые благополучно проходят через LINT, гарантируется отсутствие ошибок типа примерно с той же полнотой, как и для программ, написанных, например, на АЛГОЛЕ-68. Другие возможности программы LINT будут отмечены, когда представится соответствующий случай.

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

Некоторые операции имеют неудачное старшинство;

некоторые разделы синтаксиса могли бы быть лучше;

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

Содержание книги организовано следующим образом.

Глава 1 является учебным введением в центральную часть языка "C".

Цель — позволить читателю стартовать так быстро,как только возможно, так как мы твердо убеждены, что единственный способ изучить новый язык — писать на нем программы. При этом, однако, предполагается рабочее владение основными элементами программирования;

здесь не объясняется, что такое ЭВМ или компилятор, не поясняется смысл выражений типа N=N+1. Хотя мы и пытались, где это возможно, продемонстрировать полезную технику программирования. Эта книга не предназначается быть справочным руководством по структурам данных и алгоритмам;

там, где мы вынуждены были сделать выбор, мы концентрировались на языке.

В главах со 2-й по 6-ю различные аспекты "C" излагаются более детально и несколько более формально, чем в главе 1, хотя ударение по-прежнему делается на разборе примеров законченных, полезных программ, а не на отдельных фрагментах.

В главе 2 обсуждаются основные типы данных, операторы и выражения. В главе 3 рассматриваются управляющие операторы: IF-ELSE, WHILE, FOR и т.д. Глава 4 охватывает функции и структуру программы — внешние переменные, правила Б.В. Керниган, Д.М. Ричи. Язык С.

определенных областей действия описания и т.д. В главе 5 обсуждаются указатели и адресная арифметика. Глава 6 содержит подробное описание структур и объединений.

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

В главе 8 описывается интерфейс между "C" — программами и операционной системой "UNIX". Упор делается на ввод-вывод, систему файлов и переносимость.

Хотя некоторые части этой главы специфичны для операционной системы "UNIX", программисты, не использующие "UNIX", все же должны найти здесь полезный материал, в том числе некоторое представление о том, как реализована одна версия стандартной библиотеки и предложения для достижения переносимости программы.

Приложение A содержит справочное руководство по языку "C". Оно является "официальным" изложением синтаксиса и семантики "C" и (исключая чей-либо собственный компилятор) окончательным арбитром для всех двусмысленностей и упущений в предыдущих главах.

Так как "C" является развивающимся языком, реализованным на множестве систем, часть материла настоящей книги может не соответствовать текущему состоянию разработки на какой-то конкретной системе. Мы старались избегать таких проблем и предостерегать о возможных трудностях. Всомнительных случаях, однако, мы обычно предпочитали описывать ситуацию для системы "UNIX" PDP-11, так как она является средой для большинства программирующих на языке "C". В приложении а также описаны расхождения в реализациях языка "C" на основных системах.

1. Учебное введение Давайте начнем с быстрого введения в язык "C". Наша цель — продемонстрировать существенные элементы языка на реальных программах, не увязая при этом в деталях, формальных правилах и исключениях. Вэтойглаве мыне пытаемся изложить язык полностью или хотя бы строго (разумеется, приводимые примеры будут корректными). Мы хотим как можно скорее довести вас до такого уровня, на котором вы были бы в состоянии писать полезные программы, и чтобы добиться этого, мы сосредотачиваемся на основном: переменных и константах, арифметике, операторах передачи управления, функциях и элементарных сведениях о вводе и выводе. Мы совершенно намеренно оставляем за пределами этой главы многие элементы языка "C", которые имеют первостепенное значение при написании больших программ, в том числе указатели, сртуктуры, большую часть из богатого набора операторов языка "C", несколько операторов передачи управления и несметное количество деталей.

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

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

Б.В. Керниган, Д.М. Ричи. Язык С.

Во всяком случае, опытные программисты должны оказаться в состоянии проэкстраполировать материал данной главы на свои собственные программистские нужды. Начинающие же должны в дополнение писать аналогичные маленькие самостоятельные программы. И те, и другие могут использовать эту главу как каркас, на который будут навешиваться более подробные описания, начинающиеся с главы2.

1.1. Hачинаем Единственный способ освоить новый язык программирования — писать на нем программы. Первая программа, которая должна быть написана, — одна для всех языков: напечатать слова : 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" предусмотрены следующие: \т — для табуляции, \B— для возврата на одну позицию, \" — для двойной кавычки и \\ для самой обратной косой черты.

Упражнение 1-2.

Проведите эксперименты для того, чтобы узнать что произойдет, если в строке, являющейся аргументом функции PRINTF будет содержаться \X, где X — некоторый символ, не входящий в вышеприведенный список.

1.2. Переменные и арифметика Следующая программа печатает приведенную ниже таблицу температур по Фаренгейту и их эквивалентов по стоградусной шкале Цельсия, используя для перевода формулу C = (5/9)*(F-32). 0 -17. 20 -6. 40 4. 60 15.......

260 126. 280 137. 300 140. Теперь сама программа:

/* 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" допускается совершенно произвольное расположение операторов в строке, подходящий сдвиг и использование пробелов значительно облегчают чтение программ. Мы рекомендуем писать только один оператор на строке и (обычно) оставлять пробелы вокруг операторов. Расположение фигурных скобок менее сущес твенно;

мы выбрали один из нескольких популярных стилей. Выберите подходящий для вас стиль и затем используйте его последовательно.

Основная часть работы выполняется в теле цикла. Температура по Цельсию вычисляется и присваивается переменной CELAIUS оператором CELSIUS = (5.0/9.0) * (FAHR-32.0);

Б.В. Керниган, Д.М. Ричи. Язык С.

причина использования выражения 5.0/9.0 вместо выглядящего проще 5/9 заключается в том, что в языке "C", как и во многих других языках, при делении целых происходит усечение, состоящее в отбрасывании дробной части результата. Таким образом, результат операции 5/9 равен нулю, и, конечно, в этом случае все температуры оказались бы равными нулю. Десятичная точка в константе указывает, что она имеет тип с плавающей точкой, так что, как мы и хотели, 5.0/9. равно 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.

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

Упражнение 1-4.

Напишите программы печати соответствующей таблицы перехода от градусов цельсия к градусам фаренгейта.

1.3. Оператор FOR Как и можно было ожидать, имеется множество различных способов написания каждой программы. Давайте рассмотрим такой вариант программы перевода температур:

MAIN() /* FAHRENHEIT-CELSIUS TABLE */ INT FAHR;

FOR(FAHR= 0;

FAHR<= 300;

FAHR= FAHR+ 20) PRINTF("%4D %6.1F\N", FAHR, (5.0/9.0)*(FAHR-32.0));

Эта программа выдает те же самые результаты, но выглядит безусловно по другому. Главное изменение — исключение большинства переменных;

осталась только переменная FAHR, причем типа INT (это сделано для того, чтобы продемонстрировать преобразование %D в функции PRINTF). Нижняя и верхняя границы и размер щага появляются только как константы в операторе FOR, который сам является новой конструкцией, а выражение, вычисляющее температуру по цельсию, входит теперь в виде третьего аргумента функции PRINTF, а не в виде отдельного оператора присваивания.

Последнее изменение является примером вполне общего правила языка "C" — в любом контексте, в котором допускается использование значения переменной некоторого типа, вы можете использовать выражение этого типа. Так как третий аргумент функции PRINTF должен иметь значение с плавающей точкой, чтобы соответствовать спецификации %6.1F, то в этом месте может встретиться любое выражение плавающего типа.

Сам оператор FOR — это оператор цикла, обобщающий оператор WHILE. Его функционирование должно стать ясным, если вы сравните его с ранее описанным Б.В. Керниган, Д.М. Ричи. Язык С.

оператором WHILE. Оператор FOR содержит три части, разделяемые точкой с запятой. Первая часть FAHR = выполняется один раз перед входом в сам цикл. Вторая часть проверка, или условие, которое управляет циклом:

FAHR <= это условие проверяется и, если оно истинно, то выполняется тело цикла (в данном случае только функция PRINTF ). Затем выполняется шаг реинициализации FAHR =FAHR + и условие проверяется снова. цикл завершается, когда это условие становится ложным. Так же, как и в случае оператора WHILE, тело цикла может состоять из одного оператора или из группы операторов, заключенных в фигурные скобки.

Инициализирующая и реинициализирующая части могут быть любыми отдельными выражениями.

Выбор между операторами WHILE и FOR произволен и основывается на том, что выглядит яснее. Оператор FOR обычно удобен для циклов, в которых инициализация и реинициализация логически связаны и каждая задается одним оператором, так как в этом случае запись более компактна, чем при использовании оператора WHILE, а операторы управления циклом сосредотачиваются вместе в одном месте.

Упражнение 1-5.

Модифицируйте программу перевода температур таким образом, чтобы она печатала таблицу в обратном порядке, т.е. От 300 градусов до 0.

1.4. Символические константы Последнее замечание, прежде чем мы навсегда оставим программу перевода температур. Прятать "магические числа", такие как 300 и 20, внутрь программы — это неудачная практика;

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

Фактически это имя может быть заменено абсолютно произвольным текстом, не обязательно цифрами #DEFINE LOWER 0/* LOWER LIMIT OF TABLE */ #DEFINE UPPER 300 /* UPPER LIMIT */ #DEFINE STEP 20 /* STEP SIZE */ Б.В. Керниган, Д.М. Ричи. Язык С.

MAIN () /* FAHRENHEIT-CELSIUS TABLE */ INT FAHR;

FOR (FAHR =LOWER;

FAHR <= UPPER;

FAHR =FAHR + STEP) PRINTF("%4D %6.1F\N", FAHR, (5.0/9.0)*(FAHR-32));

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

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

1.5.1. Ввод и вывод символов Стандартная библиотека включает функции для чтения и записи по одному символу за один раз. функция GETCHAR() извлекает следующий вводимый символ каждый раз, как к ней обращаются, и возвращает этот символ в качестве своего значения. Это значит, что после C= GETCHAR() переменная 'C' содержит следующий символ из входных данных.

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

Функция PUTCHAR(C) является дополнением к GETCHAR : в результате обращения PUTCHAR (C) содержимое переменной 'C' выдается на некоторый выходной носитель, обычно опять на терминал. Обращение к функциям PUTCHAR и PRINTF могут перемежаться;

выдача будет появляться в том порядке, в котором происходят обращения.

Как и функция PRINTF, функции GETCHAR и PUTCHAR не содержат ничего экстраординарного. Они не входят в состав языка "C", но к ним всегда можно обратиться.

1.5.2. Копирование файла Имея в своем распоряжении только функции GETCHAR и PUTCHAR вы можете, не зная ничего более об операциях ввода-вывода, написать удивительное количество полезных программ. Простейшим примером может служить программа посимвольного копирования вводного файла в выводной. Общая схема имеет вид:

Б.В. Керниган, Д.М. Ричи. Язык С.

ввести символ WHILE (символ не является признаком конца файла) вывести только что прочитанный символ ввести новый символ программа, написанная на языке "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 - либо #DEFINE EOF Использовав символическую константу 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/.

1.5.3. Подсчет символов Следующая программа подсчитывает число символов;

она представляет собой небольшое развитие программы копирования.

MAIN() /* COUNT CHARACTERS IN INPUT */ LONG NC;

Б.В. Керниган, Д.М. Ричи. Язык С.

NC = 0;

WHILE (GETCHAR() != EOF ) ++NC;

PRINTF("%1D\N", NC);

Оператор ++NC;

демонстрирует новую операцию, ++, которая означает увеличе ние на единицу. Вы могли бы написать NC = NC + 1, но ++NC более кратко и зачастую более эффективно. Имеется соответст вующая операция — уменьшение на единицу. Операции ++ и - могут быть либо префиксными (++NC), либо постфиксными (NC++);

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

Программа подсчета символов накапливает их количество в переменной типа LONG, а не INT. На PDP-11 максимальное значение равно 32767, и если описать счетчик как INT, то он будет переполняться даже при сравнительно малом файле ввода;

на языке "C" для HONEYWELL и IBM типы LONG и INT являются синонимами и имеют значительно больший размер. Спецификация преобразования %1D указывает PRINTF, что соответствующий аргумент является целым типа LONG.

Чтобы справиться с еще большими числами, вы можете использовать тип DOUBLE / FLOAT двойной длины/. мы также используем оператор FOR вместо WHILE с тем, чтобы проиллюстрировать другой способ записи цикла.

MAIN() /* COUNT CHARACTERS IN INPUT */ DOUBLE NC;

FOR (NC = 0;

GETCHAR() != EOF;

++NC) ;

PRINTF("%.0F\N", NC);

Функция PRINTF использует спецификацию %F как для FLOAT, так и для DOUBLE ;

спецификация %.0F подавляет печать несуществующейдробнойчасти.

Тело оператора цикла FOR здесь пусто, так как вся работа выполняется в проверочной и реинициализационной частях. Но грамматические правила языка "C" требуют, чтобы оператор FOR имел тело. Изолированная точка с запятой, соответствуюшая пустому оператору, появляется здесь, чтобы удовлетворить этому требованию. Мы выделили ее на отдельную строку, чтобы сделать ее более заметной.

Б.В. Керниган, Д.М. Ричи. Язык С.

Прежде чем мы распростимся с программой подсчета символов, отметим, что если файл ввода не содержит никаких символов, то условие в WHILE или FOR не выполнится при самом первом обращении к GETCHAR, и, следовательно, программа выдаст нуль, т.е. Правильный ответ. это важное замечание. одним из приятных свойств операторов WHILE и FOR является то, что они проверяют условие в начале цикла, т.е. До выполнения тела. Если делать ничего не надо, то ничего не будет сдела но, даже если это означает, что тело цикла никогда не будет выполняться. программы должны действовать разумно, когда они обращаются с файлами типа "никаких символов". Операторы WHILE и FOR помогают обеспечить правильное поведение программ при граничных значениях проверяемых условий.

1.5.4. Подсчет строк Следующая программа подсчитывает количество строк в файле ввода.

Предполагается, что строки ввода заканчиваются символом новой строки \N, скрупулезно добавленным к каждой выписанной строке.

MAIN() /* COUNT LINES IN INPUT */ INT C,NL;

NL = 0;

WHILE ((C = GETCHAR()) != EOF) IF (C =='\N') ++NL;

PRINTF("%D\N", NL);

Тело WHILE теперь содержит оператор IF, который в свою очередь управляет оператором увеличения ++NL. Оператор IF проверяет заключенное в круглые скобки условие и, если оно истинно, выполняет следующий за ним оператор /или группу операторов, заключенных в фигурные скобки/. Мы опять использовали сдвиг вправо, чтобы показать, что чем управляет.

Удвоенный знак равенства == является обозначением в языке "C" для "равно" /аналогично.EQ. В фортране/. Этот символ введен для того, чтобы отличать проверку на равенство от одиночного =, используемого при присваивании. Поскольку в типичных "C" — программах знак присваивания встречается примерно в два раза чаще, чем проверка на равенство, то естественно, чтобы знак оператора был вполовину короче.

Любой отдельный символ может быть записан внутри одиночных кавычек, и при этом ему соответствует значение, равное численному значению этого символа в машинном наборе символов;

это называется символьной константой. Так, например, 'A' — символьная константа;

ее значение в наборе символов ASCII /американский стандартный код для обмена информацией/ равно 65, внутреннему представлению символа а. Конечно, 'A' предпочтительнее, чем 65: его смысл очевиден и он не зависит от конкретного машинного набора символов.

Условные последовательности, используемые в символьных строках, также занимают законное место среди символьных констант. Так в проверках и арифметических выражениях '\N' представляет значение символа новой строки. Вы Б.В. Керниган, Д.М. Ричи. Язык С.

должны твердо уяснить, что '\N' — отдельный символ, который в выражениях эквивалентен одиночному целому;

с другой стороны "\N" — это символьная строка, которая содержит только один символ. Вопрос о сопоставлении строк и символов обсуждается в главе 2.

Упражнение 1-6.

Напишите программу для подсчета пробелов, табуляций и новых строк.

Упражнение 1-7.

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

1.5.5. Подсчет слов Четвертая программа из нашей серии полезных программ подсчитывает количество строк, слов и символов, используя при этом весьма широкое определение, что словом является любая последовательность символов, не содержащая пробелов, табуляций или новых строк. /Это — упрощенная версия утилиты 'WC' системы 'UNIX'/ #DEFINE YES #DEFINE NO MAIN() /* COUNT LINES, WORDS, CHARS IN INPUT */ INTC, NL, NW, INWORD;

INWORD = NO;

NL = NW= NC= 0;

WHILE((C = GETCHAR()) != EOF) ++NC;

IF (C == '\N') ++NL;

IF (C==' ' \!\! C=='\N' \!\! C=='\T') INWORD = NO;

ELSE IF (INWORD == NO) INWORD = YES;

++NW;

PRINTF("%D %D %D\N", NL, NW, NC);

Каждый раз, когда программа встречает первый символ слова, она увеличивает счетчик числа слов на единицу. Переменная INWORD следит за тем, находится ли программа в настоящий момент внутри слова или нет;

сначала этой переменной присваивается " не в слове", чему соответствует значение NO. Мы предпочитаем Б.В. Керниган, Д.М. Ричи. Язык С.

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

Строка NL = NW= NC= 0;

полагает все три переменные равными нулю. Это не особый случай, а следствие того обстоятельства, что оператору присваивания соответствует некоторое значение и присваивания проводятся последовательно справа налево. Таким образом, дело обстоит так, как если бы мы написали NC = (NL = (NW = 0));

операция \!\! Означает OR, так что строка IF( C==' ' \!\! C=='\N' \!\! C=='\T') говорит "если с — пробел, или с — символ новой строки, или с -табуляция..."./условная последовательность \T является изображением символа табуляции/.

Имеется соответствующая операция && для AND. Выражения, связанные операциями && или \!\!, Рассматриваются слева на право, и при этом гарантируется, что оценивание выражений будет прекращено, как только станет ясно, является ли все выражение истинным или ложным. Так, если 'C' оказывается пробелом, то нет никакой необходимости проверять, является ли 'C' символом новой строки или табуляции, итакие проверки действительно не делаются. В данном случае это не имеет принципиального значения, но, как мы скоро увидим, в более сложных ситуациях эта особенность языка весьма существенна.

Этот пример также демонстрирует оператор ELSE языка "C", который указывает то действие, которое должно выполняться, если условие, содержащееся в операторе IF, окажется ложным.

Общая форма такова:

IF (выражение) оператор-1 ELSE оператор- Выполняется один и только один из двух операторов, связанных с конструкцией IF-ELSE. Если выражение истинно, выполняется оператор-1;

если нет — выполняется оператор-2. Фактически каждый оператор может быть довольно сложным. В программе подсчета слов оператор, следующий за ELSE, является опертором IF, который управляет двумя операторами в фигурных скобках.

Б.В. Керниган, Д.М. Ричи. Язык С.

Упражнение 1-9.

Как бы вы стали проверять программу подсчета слов?

Kакие имеются ограничения?

Упражнение 1-10.

Напишите программу, которая будет печатать слова из файла ввода, причем по одному на строку.

Упражнение 1-11.

Переделайте программу подсчета слов, используя лучшее пределение "слова";

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

1.6. Массивы Давайте напишем программу подсчета числа появлений каждой цифры, символов пустых промежутков/пробел, табуляции, новая строка/ и всех остальных символов. Конечно, такая задача несколько искусственна, но она позволит нам проиллюстрировать в одной программе сразу несколько аспектов языка "C".

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

MAIN() /* COUNT DIGITS, WHITE SPACE, OTHERS */ INT C, I, NWHITE, NOTHER;

INT NDIGIT[10];

NWHITE = NOTHER = 0;

FOR (I = 0;

I < 10;

++I) NDIGIT[I] = 0;

WHILE ((C = GETCHAR()) != EOF) IF (C >= '0' && C <= '9') ++NDIGIT[C-'0'];

ELSE IF(C== ' ' \!\! C== '\N' \!\! C== '\T') ++NWHITE;

ELSE ++NOTHER;

PRINTF("DIGITS =");

FOR (I = 0;

I < 10;

++I) PRINTF(" %D", NDIGIT[I]);

PRINTF("\NWHITE SPACE = %D, OTHER = %D\N", Б.В. Керниган, Д.М. Ричи. Язык С.

NWHITE, NOTHER);

Описание INT NDIGIT[10];

объявляет, что NDIGIT является массивом из десяти целых. в языке "C" индексы массива всегда начинаются с нуля /а не с 1, как в фортране или PL/1/, так что элементами массива яв ляются NDIGIT[0], NDIGIT[1],..., NDIGIT[9]. эта особенность отражена в циклах FOR, которые инициализируют и печатают массив.

Индекс может быть любым целым выражением, которое, конечно, может включать целые переменные, такие как I, ицелые константы.

Эта конкретная программа сильно опирается на свойства символьного представления цифр. Так, например, в программе проверка IF( C >= '0' && C <= '9')...

определяет, является ли символ в 'C' цифрой, и если это так, то численное значение этой цифры определяется по формуле / C - '0'/. Такой способ работает только в том случае, если значения символьных констант '0', '1' и т.д. Положительны, расположены в порядке возрастания и нет ничего, кроме цифр, между константами '0' и '9'. К счастью, это верно для всех общепринятых наборов символов.

По определению перед проведением арифметических операций, вовлекающих переменные типа CHAR и INT, все они преобразуются к типу INT, TAK что в арифметических выражениях переменные типа CHAR по существу идентичны переменным типа INT. Это вполне естественно и удобно;

например, C -'0'- это целое выражение со значением между 0 и 9 в соответствии с тем, какой символ от '0' до '9' хранится в 'C', и, следовательно, оно является подходящим индексом для массива NDIGIT.

Выяснение вопроса, является ли данный символ цифрой, символом пустого промежутка или чем-либо еще, осуществляется последовательностью операторов IF (C >= '0' && C <= '9') ++NDIGIT[C-'0'];

ELSE IF(C == ' ' \!\! C == '\N' \!\! C == '\T') ++NWHITE;

ELSE ++NOTHER;

Конструкция Б.В. Керниган, Д.М. Ричи. Язык С.

IF (условие) оператор ELSE IF (условие) оператор ELSE оператор часто встречаются в программах как средство выражения ситуаций, в которых осуществляется выбор одного из нескольких возможных решений.

Программа просто движется сверху вниз до тех пор, пока не удовлетворится какое-нибудь условие;

тогда выполняется соответствующий 'оператор', и вся конструкция завершается. /Конечно, 'оператор' может состоять из нескольких операторов, заключенных в фигурные скобки/. Если ни одно из условий не удовлетворяется, то выполняется 'оператор', стоящий после заключительного ELSE, если оно присутствует. Если последнеE ELSE и соответствующий 'оператор' опущены (как в программе подсчета слов), то никаких действий не производится. Между начальным IF иконечнымELSE может помещаться произвольное количество групп ELSE IF (условие) оператор С точки зрения стиля целесообразно записывать эту конструкцию так, как мы показали, с тем чтобы длинные выражения не залезали за правый край страницы.

Оператор SWITCH (переключатель), который рассматривается в главе 3, представляет другую возможность для записи разветвления на несколько вариантов.

этот оператор особенно удобен, когда проверяемое выражение является либо просто некоторым целым, либо символьным выражением, совпадающим с одной из некоторого набора констант. Версия этой программы, использующая оператор SWITCH, будет для сравнения приведена в главе 3.

Упражнение 1-12.

Напишите программу, печатающую гистограмму длин слов из файла ввода.

Самое легкое — начертить гистограмму горизонтально;

вертикальная ориентация требует больших усилий.

1.7. Функции В языке "C" функции эквивалентны подпрограммам или функциям в фортране или процедурам в PL/1, паскале и т.д. Функции дают удобный способ заключения некоторой части вычислений в черный ящик, который в дальнейшем можно использовать, не интересуясь его внутренним содержанием. Использование функций является фактически единственным способом справиться с потенциальной сложностью больших программ. Если функции организованы должным образом, то можно игнорировать то, как делается работа;

достаточно знание того, что делается.

Язык "C" разработан таким образом, чтобы сделать использование функций легким, удобным и эффективным. Вам будут часто встречаться функции длиной всего в несколько строчек, вызываемые только один раз, и они используются только потому, что это проясняет некоторую часть программы.

До сих пор мы использовали только предоставленные нам функции типа PRINTF, GETCHAR и PUTCHAR;

теперь пора написать несколько наших собственных. так как в "C" нет операции возведения в степень, подобной операции ** в фортране или PL/1, Б.В. Керниган, Д.М. Ричи. Язык С.

давайте проиллюстрируем механику определения функции на примере функции POWER(M,N), возводящей целое м в целую положительную степень N. Так значение POWER(2,5) равно 32. Конечно, эта функция не выполняет всей работы операции **, поскольку она действует только с положительными степенями небольших чисел, но лучше не создавать дополнительных затруднений, смешивая несколько различных вопросов.

Ниже приводится функция POWER и использующая ее основная программа, так что вы можете видеть целиком всю структуру.

MAIN() /* TEST POWER FUNCTION */ INT I;

FOR(I =0;

I <10;

++I) PRINTF("%D %D %D\N",I,POWER(2,I),POWER(-3,I));

POWER(X,N) /* RAISE X N-TH POWER;

N > 0 */ INT X,N;

INT I, P;

P= 1;

FOR(I =1;

I <=N;

++I) P= P* X;

RETURN (P);

Все функции имеют одинаковый вид:

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

Функция POWER вызывается дважды в строке PRINTF("%D %D %D\N",I,POWER(2,I),POWER(-3,I));

Б.В. Керниган, Д.М. Ричи. Язык С.

при каждом обращении функция POWER, получив два аргумента, вазвращает целое значение, которое печатается в заданном формате. В выражениях POWER(2,I) является точно таким же це лым, как 2 и I. /Не все функции выдают целое значение;

мы займемся этим вопросом в главе 4/.

Аргументы функции POWER должны быть описаны соответствующим образом, так как их типы известны. Это сделано в строке INT X,N;

которая следует за именем функции.

Описания аргументов помещаются между списком аргументов и открывающейся левой фигурной скобкой;

каждое описание заканчивается точкой с запятой. Имена, использованные для аргументов функции POWER, являются чисто локальными и недоступны никаким другим функциям: другие процедуры могут ис пользовать те же самые имена без возникновения конфликта. Это верно и для переменных I и P;

I вфункцииPOWER никак не связано с I вфункцииMAIN.

Значение, вычисленное функцией POWER, передаются в MAIN с помощью оператора RETURN, точно такого же, как в PL/1. внутри круглых скобок можно написать любое выражение. Функция не обязана возвращать какое-либо значение;

оператор RETURN, не содержащий никакого выражения, приводит к такой же передаче управления, как "сваливание на конец" функции при достижении конечной правой фигурной скобки, но при этом в вызывающую функцию не возвращается никакого полезного значения.

Упражнение 1-13.

Апишите программу преобразования прописных букв из айла ввода в строчные, используя при этом функцию OWER(C), которая возвращает значение 'C', если C'- не буква, и значение соответствующей строчной уквы, если 'C'-буква.

1.8. Аргументы — вызов по значению Один аспект в "C" может оказаться непривычным для программистов, которые использовали другие языки, в частности, фортран и PL/1. в языке "C" все аргументы функций передаются "по значению". это означает, что вызванная функция получает значения своих аргументов с помощью временных переменных /фактически через стек/, а не их адреса. Это приводит к некоторым особенностям, отличным от тех, с которыми мы сталкивались в языках типа фортрана и PL/1, использующих "вызов по ссылке ", где вызванная процедура работает с адресом аргумента, а не с его значением.

Главное отличие состоит в том, что в "C" вызванная функция не может изменить переменную из вызывающей функции;

она может менять только свою собственную временную копию.

Вызов по значению, однако, не помеха, а весьма ценное качество. Оно обычно приводит к более компактным программам, содержащим меньше не относящихся к делу переменных, потому что с аргументами можно обращаться как с удобно инициализированными локальными перемнными вызванной процедуры. Вот, например, вариант функции POWER использующей это обстоятельство Б.В. Керниган, Д.М. Ричи. Язык С.

POWER(X,N) /* RAISE X N-TH POWER;

N > 0;

VERSION 2 */ INT X,N;

INT P;

FOR (P = 1;

N > 0;

--N) P= P* X;

RETURN (P);

Аргумент N используется как временная переменная;

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

чтобы ни происходило с N внутри POWER это никак не влияет на аргумент, с которым первоначально обратились к функции POWER.

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

Когда в качестве аргумента выступает имя массива, то фактическим значением, передаваемым функции, является адрес начала массива. /Здесь нет никакого копирования элементов массива/. С помощью индексации и адреса начала функция может найти и изменить любой элемент массива. Это — тема следующего раздела.

1.9. Массивы символов По-видимому самым общим типом массива в "C" является массив символов.

Чтобы проиллюстрировать использование массивов символов и обрабатывающих их функций, давайте напишем программу, которая читает набор строк и печатает самую длинную из них. Основная схема программы достаточно проста:

WHILE (имеется еще строка) IF (эта строка длиннее самой длинной из предыдущих) запомнить эту строку и ее длину напечатать самую длинную строку По этой схеме ясно, что программа естественным образом распадается на несколько частей. Одна часть читает новую строку, другая проверяет ее, третья запоминает, а остальные части программы управляют этим процессом.

Поскольку все так прекрасно делится, было бы хорошо и написать программу соответсвующим образом. Давайте сначала напишем отдельную функцию GETLINE, которая будет извлекать следующую строку из файла ввода;

это — обобщение функции GETCHAR. мы попытаемся сделать эту функцию по возможности более гибкой, чтобы она была полезной и в других ситуациях. Как минимум GETLINE должна передавать сигнал о возможном появлении конца файла;

более общий полезный вариант мог бы передавать длину строки или нуль, если встретится конец файла. нуль не может быть длиной строки, так как каждая строка содержит по Б.В. Керниган, Д.М. Ричи. Язык С.

крайней мере один символ;

даже строка, содержащая только символ новой строки, имеет длину 1.

Когда мы находим строку, которая длиннее самой длинной из предыдущих, то ее надо где-то запомнить. Это наводит на мысль о другой функции, COPY, которая будет копировать новую строку в место хранения.

Наконец, нам нужна основная программа для управления функциями GETLINE и COPY. Вот результат :

#DEFINE MAXLINE 1000 /* MAXIMUM INPUT LINE SIZE */ MAIN() /* FIND LONGEST LINE */ INT LEN;

/* CURRENT LINE LENGTH */ INT MAX;

/* MAXIMUM LENGTH SEEN SO FAR */ CHAR LINE[MAXLINE];

/* CURRENT INPUT LINE */ CHAR SAVE[MAXLINE];

/* LONGEST LINE, SAVED */ MAX = 0;

WHILE ((LEN = GETLINE(LINE, MAXLINE)) > 0) IF (LEN > MAX) MAX = LEN;

COPY(LINE, SAVE);

IF (MAX > 0) /* THERE WAS A LINE */ PRINTF("%S", SAVE);

GETLINE(S,LIM) /* GET LINE INTO S,RETURN LENGTH */ CHAR S[];

INT LIM;

INT C, I;

FOR(I=0;

I

++I) S[I] = C;

IF (C == '\N') S[I] = C;

++I;

S[I] = '\0';

RETURN(I);

Б.В. Керниган, Д.М. Ричи. Язык С.

COPY(S1, S2) /* COPY S1 TO S2;

ASSUME S2 BIG ENOUGH */ CHAR S1[], S2[];

INT I;

I =0;

WHILE ((S2[I] = S1[I] != '\0') ++I;

Функция MAIN и GETLINE общаются как через пару аргументов, так и через возвращаемое значение. аргументы GETLINE описаны в строках CHAR S[];

INT LIM;

которые указывают, что первый аргумент является массивом, а второй — целым.

Длина массива S не указана, так как она определена в MAIN. функция GETLINE использует оператор RETURN для передачи значения назад в вызывающую программу точно так же, как это делала функция POWER. Одни функции возвращают некоторое нужное значение;

другие, подобно COPY, используются из-за их действия и не возвращают никакого значения.

Чтобы пометить конец строки символов, функция GETLINE помещает в конец создаваемого ей массива символ \0 /нулевой символ, значение которого равно нулю/.

Это соглашение используется также компилятором с языка "C": когда в "C" — программе встречается строчная константа типа "HELLO\N" то компилятор создает массив символов, содержащий символы этой строки, и заканчивает его символом \0, с темчтобыфункции, подобные PRINTF, могли зафиксировать конец массива:

------------------------------------------ ! H ! E ! L ! L ! O ! \N ! \0 !

Спецификация формата %S указывает, что PRINTF ожидает строку, представленную в такой форме. Проанализировав функцию COPY, вы обнаружите, что и она опирается на тот факт, что ее входной аргумент оканчивается символом \0, и копирует этот символ в выходной аргумент S2. /Все это подразумевает, что символ \ не является частью нормального текста/.

Между прочим, стоит отметить, что даже в такой маленькой программе, как эта, возникает несколько неприятных организационных проблем. Например, что должна делать MAIN, если она встретит строку, превышающую ее максимально возможный Б.В. Керниган, Д.М. Ричи. Язык С.

размер? Функция GETLINE поступает разумно: при заполнении массива она прекращает дальнейшее извлечение символов, даже если не встречает символа новой строки. Проверив полученную длину и последний символ, функция MAIN может установить, не была ли эта строка слишком длинной, и поступить затем, как она сочтет нужным. Ради краткости мы опустили эту проблему.

Пользователь функции GETLINE никак не может заранее узнать, насколько длинной окажется вводимая строка. Поэтому в GETLINE включен контроль переполнения. в то же время пользователь функции COPY уже знает /или может узнать/, каков размер строк, так что мы предпочли не включать в эту функцию дополнительный контроль.

Упражнение 1-14.

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

Упржнение 1-15.

Напишите программу печати всех строк длиннее 80 символов.

Упражнение 1-16.

Напишите программу, которая будет удалять из каждой строки стоящие в конце пробелы и табуляции, а также строки, целиком состоящие из пробелов.

Упражнение 1-17.

Напишите функцию REVERSE(S), которая распологает символьную строку S в обратном порядке. С ее помощью напишите программу, которая обратит каждую строку из файла ввода.

1.10. Область действия: внешние переменные Переменные в MAIN(LINE, SAVE и т.д.) являются внутренними или локальными по отношению к функции MAIN, потому что они описаны внутри MAIN и никакая другая функция не имеет к ним прямого доступа. Это же верно и относительно переменных в других функциях;

например, переменная I в функции GETLINE никак не связана с I в COPY. Каждая локальная переменная существует только тогда, когда произошло обращение к соответствующей функции, и исчезает, как только закончится выполнение этой функции. По этой причине такие переменные, следуя терминологии других языков, обычно называют автоматическими. Мы впредь будем использовать термин автоматические при ссылке на эти динамические локальные переменные. /в главе 4 обсуждается класс статической памяти, когда локальные переменные все же оказываются в состоянии сохранить свои значения между обращениями к функциям/.

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

В качестве альтернативы к автоматическим переменным можно определить переменные, которые будут внешними для всех функций, т.е. Глобальными переменными, к которым может обратиться по имени любая функция, которая пожелает это сделать. (этот механизм весьма сходен с "COMMON" в фортране и "EXTERNAL" в PL/1). Так как внешние переменные доступны всюду, их можно использовать вместо списка аргументов для передачи данных между функциями.

Кроме того, поскольку внешние переменные существуют постоянно, а не появляются Б.В. Керниган, Д.М. Ричи. Язык С.

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

Внешняя переменная должна быть определена вне всех функций;

при этом ей выделяется фактическое место в памяти. Такая переменная должна быть также описана в каждой функции, которая собирается ее использовать;

это можно сделать либо явным описанием EXTERN, либо неявным по контексту. Чтобы сделать обсуждение более конкретным, давайте перепишем программу поиска самой длинной строки, сделав LINE, SAVE и MAX внешними переменными. Это потребует изменения описаний и тел всех трех функций, а также обращений к ним.

#DEFINE MAXLINE 1000 /* MAX. INPUT LINE SIZE*/ CHAR LINE[MAXLINE];

/* INPUT LINE */ CHAR SAVE[MAXLINE];

/* LONGEST LINE SAVED HERE*/ INT MAX;

/*LENGTH OF LONGEST LINE SEEN SO FAR*/ MAIN() /*FIND LONGEST LINE;

SPECIALIZED VERSION*/ INT LEN;

EXTERN INT MAX;

EXTERN CHAR SAVE[];

MAX = 0;

WHILE ( (LEN = GETLINE()) > 0 ) IF ( LEN > MAX ) MAX = LEN;

COPY();

IF ( MAX > 0 ) /* THERE WAS A LINE */ PRINTF( "%S", SAVE );

GETLINE() /* SPECIALIZED VERSION */ INT C, I;

EXTERN CHAR LINE[];

FOR (I = 0;

I < MAXLINE- && (C=GETCHAR()) !=EOF && C!='\N';

++I) LINE[I] = C;

++I;

Б.В. Керниган, Д.М. Ричи. Язык С.

LINE[I] = '\0' RETURN(I) 2. Типы, операции и выражения Переменные и константы являются основными объектами, с которыми оперирует программа. Описания перечисляют переменные, которые будут использоваться, указывают их тип и, возможно, их начальные значения. Операции определяют, что с ними будет сделано. выражения объединяют переменные и константы для получения новых значений. Все это — темы настоящей главы.

2.1. Имена переменных Хотя мы этого сразу прямо не сказали, существуют некоторые ограничения на имена переменных и символических констант. Имена составляются из букв и цифр;

первый символ должен быть буквой. Подчеркивание "_" тоже считается буквой;

это полезно для удобочитаемости длинных имен переменных. Прописные и строчные буквы различаются;

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

Играют роль только первые восемь символов внутреннего имени, хотя использовать можно и больше. Для внешних имен, таких как имена функций и внешних переменных, это число может оказаться меньше восьми, так как внешние имена используются различными ассемблерами и загрузчиками. Детали приводятся в приложении а. Кроме того, такие ключевые слова как IF, ELSE, INT, FLOAT и т.д., зарезервированы: вы не можете использовать их в качестве имен переменных. (Они пишутся строчными буквами).

Конечно, разумно выбирать имена переменных таким образом, чтобы они означали нечто, относящееся к назначению переменных, и чтобы было менее вероятно спутать их при написании.

2.2. Типы и размеры данных Языке "C" имеется только несколько основных типов данных:

CHAR один байт, в котором может находиться один символ из внутреннего набора символов.

INT Целое, обычно соответствующее естественному размеру целых в используемой машине.

FLOAT С плавающей точкой одинарной точности.

DOUBLE С плавающей точкой двойной точности.

Кроме того имеется ряд квалификаторов, которые можно использовать с типом INT: SHORT (короткое), LONG (длинное) и UNSIGNED (без знака). Квалификаторы SHORT и LONG указывают на различные размеры целых. Числа без знака подчиняются законам арифметики по модулю 2 в степени N, где N — число битов в INT;

числа без знаков всегда положительны. Описания с квалификаторами имеют вид:

SHORT INT X;

Б.В. Керниган, Д.М. Ричи. Язык С.

LONG INT Y;

UNSIGNED INT Z;

Cлово INT в таких ситуациях может быть опущено, что обычно и делается.

Количество битов, отводимых под эти объекты зависит от имеющейся машины;

в таблице ниже приведены некоторые характерные значения.

Таблица !

INTERDATA !

DEC PDP-11 HONEYWELL IBM 370 6000 8/32 !

ASCII ASCII EBCDIC ASCII !

CHAR 8-BITS 9-BITS 8 BITS 8 32 BITS !

INT163632 16 !

SHORT163616 32 !

LONG 32 36 32 32 !

FLOAT323632 64 !

DOUBLE 64 72 64 !

----------------------------------- ----------- ------- Цель состоит в том, чтобы SHORT и LONG давали возможность в зависимости от практических нужд использовать различные длины целых;

тип INT отражает наиболее "естественный" размер конкретной машины. Как вы видите, каждый компилятор свободно интерпретирует SHORT и LONG в соответствии со своими аппаратными средствами. Все, на что вы можете твердо полагаться, это то, что SHORT не длиннее, чем LONG.

2.3. Константы Константы типа INT и FLOAT мы уже рассмотрели. Отметим еще только, что как обычная 123.456е-7, так и "научная" запись 0.12е для FLOAT является законной.

Каждая константа с плавающей точкой считается имеющей тип DOUBLE, так что обозначение "E" служит как для FLOAT, так и для DOUBLE.

Длинные константы записываются в виде 123L. Обычная целая константа, которая слишком длинна для типа INT, рассматривается как LONG.

Б.В. Керниган, Д.М. Ричи. Язык С.

Существует система обозначений для восьмеричных и шестнадцатеричных констант: лидирующий 0(нуль) в константе типа INT указывает на восьмеричную константу, а стоящие впереди 0X соответствуют шестнадцатеричной константе.

Например, десятичное число 31 можно записать как 037 в восьмеричной форме и как 0X1F в шестнадцатеричной. Шестнадцатеричные и восьмеричные константы могут также заканчиваться буквой L, что делает их относящимися к типу LONG.

2.3.1. Символьная константа Символьная константа — это один символ, заключенный в одинарные кавычки, как, например, 'х'. Значением символьной константы является численное значение этого символа во внутреннем машинном наборе символов. Например, в наборе символов ASCII символьный нуль, или '0', имеет значение 48, а в коде EBCDIC — 240, и оба эти значения совершенно отличны от числа 0. Написание '0' вместо численного значения, такого как 48 или 240, делает программу не зависящей от конкретного численного представления этого символа в данной машине. Символьные константы точно так же участвуют в численных опера циях, как и любые другие числа, хотя наиболее часто они используются в сравнении с другими символами. Правила преобразования будут изложены позднее.

Некоторые неграфические символы могут быть представлены как символьные константы с помощью условных последовательностей, как, например, \N (новая строка), \T (табуляция), \0 (нулевой символ), \\ (обратная косая черта), \' (одинарная кавычка) и т.д. Хотя они выглядят как два символа, на самом деле являются одним.

Кроме того, можно сгенерировать произвольную последовательность двоичных знаков размером в байт, если написать '\DDD' где DDD — от однойдо трех восьмеричных цифр, как в #DEFINE FORMFEED '\014' /* FORM FEED */ Символьная константа '\0', изображающая символ со значением 0, часто записывается вместо целой константы 0, чтобы подчеркнуть символьную природу некоторого выражения.

2.3.2. Константное выражение Константное выражение — это выражение, состоящее из одних констант. Такие выражения обрабатываются во время компиляции, а не при прогоне программы, и соответственно могут быть использованы в любом месте, где можно использовать кон станту, как, например в #DEFINE MAXLINE CHAR LINE[MAXLINE+1];

или SECONDS = 60 * 60 * HOURS;

Б.В. Керниган, Д.М. Ричи. Язык С.

2.3.3. Строчная константа Строчная константа — это последовательность, состоящая из нуля или более символов, заключенных в двойные кавычки, как, например, "I AM A STRING" /* я — строка */ или "" /* NULL STRING */ /* нуль-строка */ Кавычки не являются частью строки, а служат только для ее ограничения. те же самые условные последовательности, которые использовались в символьных константах, применяются и в строках;

символ двойной кавычки изображается как \".

С технической точки зрения строка представляет собой массив, элементами которого являются отдельные символы. Чтобы программам было удобно определять конец строки, компилятор автоматически помещает в конец каждой строки нуль символ \0. Такое представление означает, что не накладывается конкретного ограничения на то, какую длину может иметь строка, и чтобы определить эту длину, программы должны просматривать строку полностью. При этом для физического хранения строки требуется на одну ячейку памяти больше, чем число заключенных в кавычки символов. Следующая функция STRLEN(S) вычисляет длину символьной строки S не считая конечный символ \0.

STRLEN(S) /* RETURN LENGTH OF S */ CHAR S[];

INT I;

I = 0;

WHILE (S[I] != '\0') ++I;

RETURN(I);

Будьте внимательны и не путайте символьную константу со строкой, содержащей один символ: 'X' — это не то же самое, что "X". Первое — это отдельный символ, использованный с целью получения численного значения, соответствующего букве х в машинном наборе символов. Второе — символьная строка, состоящая из одного символа (буква х) и \0.

2.4. Описания Все переменные должны быть описаны до их использования, хотя некоторые описания делаются неявно, по контексту. Описание состоит из спецификатора типа и следующего за ним списка переменных, имеющих этот тип, как, например, INT LOWER, UPPER, STEP;

CHAR C, LINE[1000];

Б.В. Керниган, Д.М. Ричи. Язык С.

Переменные можно распределять по описаниям любым образом;

приведенные выше списки можно с тем же успехом записать в виде INT LOWER;

INT UPPER;

INT STEP;

CHAR C;

CHAR LINE[1000];

Такая форма занимает больше места, но она удобна для добавления комментария к каждому описанию и для последующих модификаций.

Переменным могут быть присвоены начальные значения внутри их описания, хотя здесь имеются некоторые ограничения. Если за именем переменной следуют знак равенства и константа, то эта константа служит в качестве инициализатора, как, например, в CHAR BACKSLASH = '\\';

INT I = 0;

FLOAT EPS = 1.0E-5;

Если рассматриваемая переменная является внешней или статической, то инициализация проводится только один раз, согласно концепции до начала выполнения программы. Инициализируемым явно автоматическим переменным начальные значения присваиваются при каждом обращении к функции, в которой они описаны. Автоматические переменные, не инициализируемые явно, имеют неопределенные значения, (т.е. мусор). Внешние и статические переменные по умолчанию инициализируются нулем, но, тем не менее, их явная инициализация является признаком хорошего стиля.

Мы продолжим обсуждение вопросов инициализации, когда будем описывать новые типы данных.

2.5. Арифметические операции Бинарными арифметическими операциями являются +, -, *, / и операция деления по модулю %. Имеется унарная операция -, но не существует унарной операции +.

При делении целых дробная часть отбрасывается. Выражение X% Y дает остаток от деления X на Y и, следовательно, равно нулю, когда х делится на Y точно. Например, год является високосным, если он делится на 4, но не делится на 100, исключая то, что делящиеся на 400 годы тоже являются високосными. Поэтому IF(YEAR % 4 == 0 && YEAR % 100 != 0 \!\! YEAR % 400 == 0) год високосный Б.В. Керниган, Д.М. Ричи. Язык С.

ELSE год невисокосный Операцию % нельзя использовать с типами FLOAT или DOUBLE.

Операции + и — имеют одинаковое старшинство, которое младше одинакового уровня старшинства операций *, / и %, которые в свою очередь младше унарного минуса. Арифметические операции группируются слева направо. (Сведения о старшинстве и ассоциативности всех операций собраны в таблице в конце этой главы). Порядок выполнения ассоциативных и коммутативных операций типа + и — не фиксируется;

компилятор может перегруппировывать даже заключенные в круглые скобки выражения, связанные такими операциями. таким образом, а+(B+C) может быть вычислено как (A+B)+C. Это редко приводит к какому-либо расхождению, но если необходимо обеспечить строго определенный порядок, то нужно использовать явные промежуточные переменные.

Действия, предпринимаемые при переполнении и антипереполнении (т.е. При получении слишком маленького по абсолютной величине числа), зависят от используемой машины.

2.6. Операции отношения и логические операции Операциями отношения являются => > =< < все они имеют одинаковое старшинство. Непосредственно за ними по уровню старшинства следуют операции равенства и неравенства:

== != которые тоже имеют одинаковое старшинство. операции отношения младше арифметических операций, так что выражения типа I

Логические связки && и \!\! более интересны. Выражения, связанные операциями && и \!\!, вычисляются слева направо, причем их рассмотрение прекращается сразу же как только становится ясно, будет ли результат истиной или ложью. учет этих свойств очень существенен для написания правильно работающих программ. Рассмотрим, например, оператор цикла в считывающей строку функции GETLINE, которую мы написали в главе 1.

FOR(I=0;

I

++I) S[I]=C;

Ясно, что перед считыванием нового символа необходимо проверить, имеется ли еще место в массиве S, так что условие I

Так же неудачным было бы сравнение 'C' с EOF до обращения к функции GETCHAR : прежде чем проверять символ, его нужно считать.

Б.В. Керниган, Д.М. Ричи. Язык С.

Старшинство операции && выше, чем у \!\!, и обе они младше операций отношения и равенства. Поэтому такие выражения, как I

Унарная операция отрицания ! Преобразует ненулевой или истинный операнд в 0, а нулевой или ложный операнд в 1. Обычное использование операции !

Заключается в записи IF( ! INWORD ) Вместо IF( INWORD == 0 ) Tрудно сказать, какая форма лучше. Конструкции типа ! INWORD Читаются довольно удобно ("если не в слове"). Но в более сложных случаях они могут оказаться трудными для понимания.

Упражнение 2-1.

Напишите оператор цикла, эквивалентный приведенному выше оператору FOR, не используя операции &&.

2.7. Преобразование типов Если в выражениях встречаются операнды различных типов, то они преобразуются к общему типу в соответствии с небольшим набором правил. В общем, автоматически производятся только преобразования, имеющие смысл, такие как, например, преобразование целого в плавающее в выражениях типа F+I. Выражения же, лишенные смысла, такие как использование переменной типа FLOAT в качестве индекса, запрещены.

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

ATOI(S) /* CONVERT S TO INTEGER */ CHAR S[];

Б.В. Керниган, Д.М. Ричи. Язык С.

INT I, N;

N= 0;

FOR ( I = 0;

S[I]>='0' && S[I]<='9';

++I) N= 10 * N+ S[I] — '0';

RETURN(N);

KAK Уже обсуждалось в главе 1, выражение S[I] — '0' имеет численное значение находящегося в S[I] символа, потому что значение символов '0', '1' ит.д. образуют возрастающую последовательность расположенных подряд целых положительных чисел.

Другой пример преобразования CHAR в INT дает функция LOWER, преобразующая данную прописную букву в строчную. Если выступающий в качестве аргумента символ не является прописной буквой, то LOWER возвращает его неизменным. Приводимая ниже программа справедлива только для набора символов ASCII.

LOWER(C) /* CONVERT C TO LOWER CASE;

ASCII ONLY */ INT C;

IF( C>='A' &&C<='Z' ) RETURN( C + '@' — 'A');

ELSE /*@ Записано вместо 'A' строчного*/ RETURN(C);

Эта функция правильно работает при коде ASCII, потому что численные значения, соответствующие в этом коде прописным и строчным буквам, отличаются на постоянную величину, а каждый алфавит является сплошным — между а и Z нет ничего, кроме букв. Это последнее замечание для набора символов EBCDIC систем IBM 360/370 оказывается несправедливым, в силу чего эта программа на таких системах работает неправильно — она преобразует не только буквы.

При преобразовании символьных переменных в целые возникает один тонкий момент. Дело в том, что сам язык не указывает, должны ли переменным типа CHAR соответствовать численные значения со знаком или без знака. Может ли при преобра зовании CHAR в INT получиться отрицательное целое? К сожалению, ответ на этот вопрос меняется от машины к машине, отражая расхождения в их архитектуре. На некоторых машинах (PDP-11, например) переменная типа CHAR, крайний левый бит которой содержит 1, преобразуется в отрицательное целое ("знаковое расширение").

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

Б.В. Керниган, Д.М. Ричи. Язык С.

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

Наиболее типичным примером возникновения такой ситуации является сучай, когда значение 1 используется в качестве EOF. Рассмотрим программу CHAR C;

C = GETCHAR();

IF ( C == EOF )...

На машине, которая не осуществляет знакового расширения, переменная 'с' всегда положительна, поскольку она описана как CHAR, а так как EOF отрицательно, то условие никогда не выполняется. Чтобы избежать такой ситуации, мы всегда пре дусмотрительно использовали INT вместо CHAR для любой переменной, получающей значение от GETCHAR.

Основная же причина использования INT вместо CHAR не связана с каким-либо вопросом о возможном знаковом расширении. просто функция GETCHAR должна передавать все возможные символы (чтобы ее можно было использовать для произвольного ввода) и, кроме того, отличающееся значение EOF. Следовательно значение EOF не может быть представлено как CHAR, а должно храниться как INT.

Другой полезной формой автоматического преобразования типов является то, что выражения отношения, подобные I>J, и логические выражения, связанные операциями && и \!\!, по определению имеют значение 1, если они истинны, и 0, если они ложны. Таким образом, присваивание ISDIGIT = C >= '0' && C <= '9';

полагает ISDIGIT равным 1, если с — цифра, и равным 0 в противном случае. (В проверочной части операторов IF, WHILE, FOR и т.д. "Истинно" просто означает "не нуль").

Неявные арифметические преобразования работают в основном, как и ожидается. В общих чертах, если операция типа + или *, которая связывает два операнда (бинарная операция), имеет операнды разных типов, то перед выполнением операции "низший" тип преобразуется к "высшему" и получается результат "высшего" типа. Более точно, к каждой арифметической операции применяется следующая последовательность правил преобразования.

- Типы CHAR и SHORT преобразуются в INT, а FLOAT в DOUBLE.

- Затем, если один из операндов имеет тип DOUBLE, то другой преобразуется в DOUBLE, и результат имеет тип DOUBLE.

- В противном случае, если один из операндов имеет тип LONG, то другой преобразуется в LONG, и результат имеет тип LONG.

- В противном случае, если один из операндов имеет тип UNSIGNED, то другой преобразуется в UNSIGNED и результат имеет тип UNSIGNED.

Б.В. Керниган, Д.М. Ричи. Язык С.

- В противном случае операнды должны быть типа INT, и результат имеет тип INT.

Подчеркнем, что все переменные типа FLOAT в выражениях преобразуются в DOUBLE;

в "C" вся плавающая арифметика выполняется с двойной точностью.

Преобразования возникают и при присваиваниях;

значение правой части преобразуется к типу левой, который и является типом результата. Символьные переменные преобразуются в целые либо со знаковым расширением, либо без него, как описано выше. Обратное преобразование INT в CHAR ведет себя хорошо — лишние биты высокого порядка просто отбрасываются. Таким образом INT I;

CHAR C;

I =C;

C= I;

значение 'с' не изменяется. Это верно независимо от того, вовлекается ли знаковое расширение или нет.

Если х типа FLOAT, а I типа INT, то как х =I;

так и I =х;

приводят к преобразованиям;

при этом FLOAT преобразуется в INT отбрасыванием дробной части. Тип DOUBLE преобразуется во FLOAT округлением. Длинные целые преобразуются в более короткие целые и в переменные типа CHAR посредством отбрасывания лишних битов высокого порядка.

Так как аргумент функции является выражением, то при передаче функциям аргументов также происходит преобразование типов: в частности, CHAR и SHORT становятся INT, а FLOAT становится DOUBLE. Именно поэтому мы описывали аргументы функций как INT и DOUBLE даже тогда, когда обращались к ним с переменными типа CHAR и FLOAT.

Наконец, в любом выражении может быть осуществлено ("принуждено") явное преобразование типа с помощью конструкции, называемой перевод (CAST). В этой конструкции, имеющей вид (имя типа) выражение Выражение преобразуется к указанному типу по правилам преобразования, изложенным выше. Фактически точный смысл операции перевода можно описать следующим образом: выражение как бы присваивается некоторой переменной указанного типа, которая затем используется вместо всей конструкции. Например, библиотечная процедура SQRT ожидает аргумента типа DOUBLE и выдаст бессмысленный ответ, если к ней по небрежности обратятся с чем-нибудь иным.

таким образом, если N — целое, то выражение Б.В. Керниган, Д.М. Ричи. Язык С.

SQRT((DOUBLE) N) до передачи аргумента функции SQRT преобразует N к типу DOUBLE. (Отметим, что операция перевод преобразует значение N в надлежащий тип;

фактическое содержание переменной N при этом не изменяется). Операция перевода имрация перевода имеет тот же уровень старшинства, что и другие унарные операции, как указывается в таблице в конце этой главы.

Упражнение 2-2.

Составьте программу для функции HTOI(S), которая преобразует строку шестнадцатеричных цифр в эквивалентное ей целое значение. При этом допустимыми цифрами являются цифры от 1 до 9 ибуквыот а до F.

2.8. Операции увеличения и уменьшения В языке "C" предусмотрены две необычные операции для увеличения и уменьшения значений переменных. Операция увеличения ++ добавляет 1 к своему операнду, а операция уменьшения — вычитает 1. Мы часто использовали операцию ++ для увеличения переменных, как, например, в IF(C == '\N') ++I;

Необычный аспект заключается в том, что ++ и — можно использовать либо как префиксные операции (перед переменной, как в ++N), либо как постфиксные (после переменной: N++). Эффект в обоих случаях состоит в увеличении N. Но выражение ++N увеличивает переменную N до использования ее значения, в то время как N++ увеличивает переменную N после того, как ее значение было использовано. Это означает, что в контексте, где используется значение переменной, а не только эффект увеличения, использование ++N и N++ приводит к разным результатам. Если N=5, то х = N++;

устанавливает х равным 5, а х =++N;

полагает х равным 6. Вобоих случаях N становится равным 6.

Операции увеличения и уменьшения можно применять только к переменным;

выражения типа х=(I+J)++ являются незаконными.

В случаях, где нужен только эффект увеличения, а само значение не используется, как, например, в IF ( C == '\N' ) NL++;

выбор префиксной или постфиксной операции является делом Б.В. Керниган, Д.М. Ричи. Язык С.

вкуса. но встречаются ситуации, где нужно использовать именно ту или другую операцию. Рассмотрим, например, функцию SQUEEZE(S,C), которая удаляет символ 'с' из строки S, каждый раз, как он встречается.

SQUEEZE(S,C) /* DELETE ALL C FROM S */ CHAR S[];

INT C;

INT I, J;

FOR( I =J= 0;

S[I] != '\0';

I++) IF ( S[I] != C ) S[J++] = S[I];

S[J] = '\0';

Каждый раз, как встечается символ, отличный от 'с', он копируется в текущую позицию J, и только после этого J увеличивается на 1, чтобы быть готовым для поступления следующего символа. Это в точности эквивалентно записи IF( S[I] !=C) S[J] = S[I];

J++;

Другой пример подобной конструкции дает функция GETLINE, которую мы запрограммировали в главе 1, где можно заменить IF ( C == '\N' ) S[I] = C;

++I;

более компактной записью IF ( C == '\N' ) S[I++] = C;

В качестве третьего примера рассмотрим функцию STRCAT(S,T), которая приписывает строку т в конец строки S, образуя конкатенацию строк S ит. При этом предполагается, что в S достаточно места для хранения полученной комбинации.

Б.В. Керниган, Д.М. Ричи. Язык С.

STRCAT(S,T) /* CONCATENATE T TO END OF S */ CHAR S[], T[];

/* S MUST BE BIG ENOUGH */ INT I, J;

I = J= 0;

WHILE (S[I] != '\0') / *FIND END OF S */ I++;

WHILE((S[I++] = T[J++]) != '\0') /*COPY T*/ ;

Tак как из T в S копируется каждый символ, то для подготовки к следующему прохождению цикла постфиксная операция ++ применяется к обеим переменным I и J.

Упражнение 2-3.

Напишите другой вариант функции SQUEEZE(S1,S2), который удаляет из строки S1 каждый символ, совпадающий с каким-либо символом строки S2.

Упражнение 2-4.

Напишите программу для функции ANY(S1,S2), которая находит место первого появления в строке S1 какого-либо символа из строки S2 и, если строка S1 не содержит символов строки S2, возвращает значение -1.

2.9. Побитовые логические операции В языке предусмотрен ряд операций для работы с битами;

эти операции нельзя применять к переменным типа FLOAT или DOUBLE.

& Побитовое AND \! Побитовое включающее OR ^ побитовое исключающее OR << сдвиг влево >> сдвиг вправо \^ дополнение (унарная операция) "\" иммитирует вертикальную черту.

Побитовая операция AND часто используется для маскирования некоторого множества битов;

например, оператор C = N & Б.В. Керниган, Д.М. Ричи. Язык С.

передает в 'с' семь младших битов N, полагая остальные равными нулю. Операция 'э' побитового OR используется для включения битов:

C=Xэ MASK устанавливает на единицу те биты в х, которые равны единице в MASK.

Следует быть внимательным и отличать побитовые операции & и 'э' от логических связок && и \!\!, Которые подразумевают вычисление значения истинности слева направо. Например, если х=1, а Y=2, то значение х&Y равно нулю, в то время как значение X&&Y равно единице./почему?/ Операции сдвига << и >> осуществляют соответственно сдвиг влево и вправо своего левого операнда на число битовых позиций, задаваемых правым операндом.

Таким образом, х<<2 сдвигает х влево на две позиции, заполняя освобождающиеся биты нулями, что эквивалентно умножению на 4. Сдвиг вправо величины без знака заполняет освобождающиеся биты на некоторых машинах, таких как PDP-11, заполняются содержанием знакового бита /"арифметический сдвиг"/, а на других — нулем /"логический сдвиг"/.

Унарная операция \^ дает дополнение к целому;

это означает, что каждый бит со значением 1 получает значение 0 и наоборот. Эта операция обычно оказывается полезной в выражениях типа X & \^ где последние шесть битов х маскируются нулем. Подчеркнем, что выражение X&\^077 не зависит от длины слова и поэтому предпочтительнее, чем, например, X&0177700, где предполагается, что х занимает битов. Такая переносимая форма не требует никаких дополнительных затрат, поскольку \^077 является константным выражением и, следовательно, обрабатывается во время компиляции.

Чтобы проиллюстрировать использование некоторых операций с битами, рассмотрим функцию GETBITS(X,P,N), которая возвращает /сдвинутыми к правому краю/ начинающиеся с позиции р поле переменной х длиной N битов. мы предполагаем, что крайний правый бит имеет номер 0, и что N и р — разумно за данные положительные числа. например, GETBITS(х,4,3) возвращает сдвинутыми к правому краю биты, занимающие позиции 4,3 и 2.

GETBITS(X,P,N) /* GET N BITS FROM POSITION P */ UNSIGNED X, P, N;

RETURN((X >> (P+1-N)) & \^(\^0 << N));

Операция X >> (P+1-N) сдвигает желаемое поле в правый конец слова. Описание аргумента X как UNSIGNED гарантирует, что при сдвиге вправо освобождающиеся биты будут заполняться нулями, а не содержимым знакового бита, независимо от того, на какой машине пропускается программа. Все биты константного выражения \^0 равны 1;

сдвиг его на N позиций влево с помощью операции \^0<

маску с нулями в N крайних правых битах и единицами в остальных;

дополнение \^ создает маску с единицами в N крайних правых битах.

Упражнение 2-5.

Переделайте GETBITS таким образом, чтобы биты отсчитывались слева направо.

Упражнение 2-6.

Напишите программу для функции WORDLENGTH(), вычисляющей длину слова используемой машины, т.е. Число битов в переменной типа INT. Функция должна быть переносимой, т.е. Одна и та же исходная программа должна правильно работать на любой машине.

Упражнение 2-7.

Напишите программу для функции RIGHTROT(N,B), сдвигающей циклически целое N вправо на B битовых позиций.

Упражнение 2-8.

Напишите программу для функции INVERT(X,P,N), которая инвертирует (т.е.

Заменяет 1 на 0 и наоборот) Nбитов X, начинающихся с позиции P, оставляя другие биты неизмененными.

2.10. Операции и выражения присваивания Такие выражения, как I =I + в которых левая часть повторяется в правой части могут быть записаны в сжатой форме I += используя операцию присваивания вида +=.

Большинству бинарных операций (операций подобных +, которые имеют левый и правый операнд) соответствует операция присваивания вида оп=, где оп — одна из операций + — * / % << >> & \^ \!

Если е1 ие2 — выражения, то е1 оп= е эквивалентно е1= (е1) оп (е2) за исключением того, что выражение е1 вычисляется только один раз. Обратите внимание на круглые скобки вокруг е2:

Б.В. Керниган, Д.М. Ричи. Язык С.

X*= Y + то X= X* (Y+ 1) не X= X* Y+ В качестве примера приведем функцию BITCOUNT, которая подсчитывает число равных 1 битов у целого аргумента.

BITCOUNT(N) /* COUNT 1 BITS IN N */ UNSIGNED N;

( INT B;

FOR(B= 0;

N!= 0;

N>>= 1) IF (N & 01) B++;

RETURN(B);

) Не говоря уже о краткости, такие операторы приваивания имеют то преимущество, что они лучше соответствуют образу человеческого мышления. Мы говорим: "прибавить 2 к I" или "увеличить I на 2", но не "взять I, прибавить 2 и поместить результат опять в I". Итак, I += 2. Кроме того, в громоздких выражениях, подобных YYVAL[YYPV[P3+P4] + YYPV[P1+P2]] += Tакая операция присваивания облегчает понимание программы, так как читатель не должен скрупулезно проверять, являются ли два длинных выражения действительно одинаковыми, или задумываться, почему они не совпадают. Такая операция присваи вания может даже помочь компилятору получить более эффективную программу.

Мы уже использовали тот факт, что операция присваивания имеет некоторое значение и может входить в выражения;

самыйтипичныйпример WHILE ((C = GETCHAR()) != EOF) присваивания, использующие другие операции присваивания (+=, -= ит.д.) также могут входить в выражения, хотя это случается реже.

Типом выражения присваивания является тип его левого операнда.

Упражнение 2-9.

Б.В. Керниган, Д.М. Ричи. Язык С.

В двоичной системе счисления операция X&(X-1) обнуляет самый правый равный 1 бит переменной X.(почему?) используйте это замечание для написания более быстройверсиифункцииBITCOUNT.

2.11. Условные выражения Операторы IF (A > B) Z= A;

ELSE Z= B;

конечно вычисляют в Z максимум из а и в. Условное выражение, записанное с помощью тернарной операции "?:", предоставляет другую возможность для записи этой и аналогичных конструкций. В выражении е1? Е2: е сначала вычисляется выражение е1. Если оно отлично от нуля (истинно), то вычисляется выражение е2, которое и становится значением условного выражения. В противном случае вычисляется е3, и оно становится значением условного выражения.

Каждый раз вычисляется только одно из выражения е2 и е3. Таким образом, чтобы положить Z равным максимуму из а и в, можно написать Z= (A> B)? A: B;

/* Z= MAX(A,B) */ Следует подчеркнуть, что условное выражение действительно является выражением и может использоваться точно так же, как любое другое выражение.

Если е2 и е3 имеют разные типы, то тип результата определяется по правилам преобразования, рассмотренным ранее в этой главе. например, если F имеет тип FLOAT, а N — тип INT, то выражение (N > 0)? F : N Имеет тип DOUBLE независимо от того, положительно ли N или нет.

Так как уровень старшинства операции?: очень низок, прямо над присваиванием, то первое выражение в условном выражении можно не заключать в круглые скобки. Однако, мы все же рекомендуем это делать, так как скобки делают условную часть выражения более заметной.

Использование условных выражений часто приводит к коротким программам.

Например, следующий ниже оператор цикла печатает N элементов массива, по 10 в строке, разделяя каждый столбец одним пробелом и заканчивая каждую строку (включая последнюю) одним символом перевода строки.

OR(I = 0;

I < N;

I++) Б.В. Керниган, Д.М. Ричи. Язык С.

PRINTF("%6D%C",A[I],(I%10==9 \!\! I==N-1)? '\N' : ' ') Символ перевода строки записывается после каждого десятого элемента и после N-го элемента. За всеми остальными элементами следует один пробел. Хотя, возможно, это выглядит мудреным, было бы поучительным попытаться записать это, не используя условного выражения.

Упражнение 2-10.

Перепишите программу для функции LOWER, которая переводит прописные буквы в строчные, используя вместо конструкции IF-ELSE условное выражение.

2.12. Старшинство и порядок вычисления В приводимой ниже таблице сведены правила старшинства и ассоциативности всех операций, включая и те, которые мы еще не обсуждали. Операции, расположенные в одной строке, имеют один и тот же уровень старшинства;

строки расположены в по рядке убывания старшинства. Так, например, операции *, / и % имеют одинаковый уровень старшинства, который выше, чем уровень операций + и -.

OPERATOR ASSOCIATIVITY () [] ->. LEFT TO RIGHT ! \^ ++ — — (TYPE) * & SIZEOF RIGHT TO LEFT * / % LEFT TO RIGHT + - LEFT TO RIGHT << >> LEFT TO RIGHT < <= > >= LEFT TO RIGHT == != LEFT TO RIGHT &LEFT TO RIGHT ^LEFT TO RIGHT \! LEFT TO RIGHT && LEFT TO RIGHT \!\! LEFT TO RIGHT ?: RIGHT TO LEFT = += -= ETC. RIGHT TO LEFT, (CHAPTER 3) LEFT TO RIGHT Б.В. Керниган, Д.М. Ричи. Язык С.

Операции -> и. Используются для доступа к элементам структур;

они будут описаны в главе 6 вместе с SIZEOF (размер объекта). В главе 5 обсуждаются операции * (косвенная адресация) и &(адрес).

Отметим, что уровень старшинства побитовых логических операций &, ^ и э ниже уровня операций == и !=. Это приводит к тому, что осуществляющие побитовую проверку выражения, подобные IF((X&MASK) ==0)...

Для получения правильных результатов должны заключаться в круглые скобки.

Как уже отмечалось ранее, выражения, в которые входит одна из ассоциативных и коммутативных операций (*, +, &, ^, э), могут перегруппировываться, даже если они заключены в круглые скобки. В большинстве случаев это не приводит к каким бы то ни было расхождениям;

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

В языке "C", как и в большинстве языков, не фиксируется порядок вычисления операндов в операторе. Например в операторе вида X= F() + G();

сначала может быть вычислено F, а потом G, инаоборот;

поэтому, если либо F, либо G изменяют внешнюю переменную, от которой зависит другой операнд, то значение X может зависеть от порядка вычислений. Для обеспечения нужной последовательности промежуточные результаты можно опять запоминать во временных переменных.

Подобным же образом не фиксируется порядок вычисления аргументов функции, так что оператор PRINTF("%D %D\N",++N,POWER(2,N));

может давать (и действительно дает) на разных машинах разные результаты в зависимости от того, увеличивается ли N до или после обращения к функции POWER. Правильным решением, конечно, является запись ++N;

PRINTF("%D %D\N",N,POWER(2,N));

Обращения к функциям, вложенные операции присваивания, операции увеличения и уменьшения приводят к так называемым "побочным эффектам" — некоторые переменные изменяются как побочный результат вычисления выражений.

В любом выражении, в котором возникают побочные эффекты, могут существовать очень тонкие зависимости от порядка, в котором определяются входящие в него переменные. примером типичной неудачной ситуации является оператор A[I] = I++;

Б.В. Керниган, Д.М. Ричи. Язык С.

Возникает вопрос, старое или новое значение I служит в качестве индекса.

Компилятор может поступать разными способами и в зависимости от своей интерпретации выдавать разные результаты. Тот случай, когда происходят побочные эффекты (присваивание фактическим переменным), — оставляется на усмотрение компилятора, так как наилучший порядок сильно зависит от архитектуры машины.

Из этих рассуждений вытекает такая мораль: написание программ, зависящих от порядка вычислений, является плохим методом программирования на любом языке. Конечно, необходимо знать, чего следует избегать, но если вы не в курсе, как некоторые вещи реализованы на разных машинах, это неведение может предохранить вас от неприятностей. (Отладочная программа LINT укажет большинство мест, зависящих от порядка вычислений.

3. Поток управления Управляющие операторы языка определяют порядок вычислений. В приведенных ранее примерах мы уже встречались с наиболее употребительными управляющими конструкциями языка "C";

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

3.1. Операторы и блоки Такие выражения, как X=0, или I++, или PRINTF(...), становятся операторами, если за ними следует точка с запятой, как, например, X= 0;

I++;

PRINTF(...);

В языке "C" точка с запятой является признаком конца оператора, а не разделителем операторов, как в языках типа алгола.

Фигурные скобки /( и /) используются для объединения описаний и операторов в составной оператор или блок, так что они оказываются синтаксически эквивалентны одному оператору. Один явный пример такого типа дают фигурные скобки, в кото рые заключаются операторы, составляющие функцию, другой — фигурные скобки вокруг группы операторов в конструкциях IF, ELSE, WHILE и FOR.(на самом деле переменные могут быть описаны внутри любого блока;

мы поговорим об этом в главе 4). Точка с запятой никогда не ставится после первой фигурной скобки, которая завершает блок.

3.2. IF — ELSE Оператор IF — ELSE используется при необходимости сделать выбор. Формально синтаксис имеет вид IF (выражение) оператор- ELSE оператор-2, Б.В. Керниган, Д.М. Ричи. Язык С.

Где часть ELSE является необязательной. Сначала вычисляется выражение;

если оно "истинно" /т.е. значение выражения отлично от нуля/, то выполняется оператор 1. Если оно ложно /значение выражения равно нулю/, и если есть часть с ELSE, то вместо оператора-1 выполняется оператор-2.

Так как IF просто проверяет численное значение выражения, то возможно некоторое сокращение записи. Самой очевидной возможностью является запись IF (выражение) вместо IF (выражение !=0) иногда такая запись является ясной и естественной, но временами она становится загадочной.

То, что часть ELSE в конструкции IF — ELSE является необязательной, приводит к двусмысленности в случае, когда ELSE опускается во вложенной последовательности операторов IF. Эта неоднозначность разрешается обычным образом — ELSE связывается с ближайшим предыдущим IF, не содержащим ELSE.

Например, в IF ( N > 0 ) IF( A > B ) Z= A;

ELSE Z= B;

конструкция ELSE относится к внутреннему IF, как мы и показали, сдвинув ELSE под соответствующий IF. Если это не то, что вы хотите, то для получения нужного соответствия необходимо использовать фигурные скобки:

IF (N > 0) IF (A > B) Z= A;

ELSE Z= B;

Tакая двусмысленность особенно пагубна в ситуациях типа IF (N > 0) FOR (I = 0;

I < N;

I++) IF (S[I] > 0) PRINTF("...");

Б.В. Керниган, Д.М. Ричи. Язык С.

RETURN(I);

ELSE /* WRONG */ PRINTF("ERROR — N IS ZERO\N");

Запись ELSE под IF ясно показывает, чего вы хотите, но компилятор не получит соответствующего указания и свяжет ELSE с внутренним IF. Ошибки такого рода очень трудно обнаруживаются.

Между прочим, обратите внимание, что в IF (A > B) Z= A;

ELSE Z= B;

после Z=A стоит точка с запятой. Дело в том, что согласно грамматическим правилам за IF должен следовать оператор, а выражение типа Z=A, являющееся оператором, всегда заканчивается точкой с запятой.

3.3. ELSE — IF Конструкция IF (выражение) оператор ELSE IF (выражение) оператор ELSE IF (выражение) оператор ELSE оператор встречается настолько часто, что заслуживает отдельного краткого рассмотрения. Такая последовательность операторов IF является наиболее распространенным способом программирования выбора из нескольких возможных вариантов. выражения просматриваются последовательно;

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

Последняя часть с ELSE имеет дело со случаем, когда ни одно из проверяемых условий не выполняется. Иногда при этом не надо предпринимать никаких явных действий;

в этомслучае хвост ELSE оператор может быть опущен, или его можно использовать для контроля, Б.В. Керниган, Д.М. Ричи. Язык С.

чтобы засечь "невозможное" условие.

Для иллюстрации выбора из трех возможных вариантов приведем программу функции, которая методом половинного деления определяет, находится ли данное значение х в отсортированном массиве V. Элементы массива V должны быть расположены в порядке возрастания. Функция возвращает номер позиции (число между 0 и N-1), в которой значение х находится в V, и -1, если х не содержится в V.

BINARY(X, V, N) /* FIND X IN V[0]...V[N-1] */ INTX, V[], N;

INT LOW, HIGH, MID;

LOW = 0;

HIGH = N — 1;

WHILE (LOW <= HIGH) MID = (LOW + HIGH) / 2;

IF (X < V[MID]) HIGH = MID — 1;

ELSE IF (X > V[MID]) LOW = MID + 1;

ELSE /* FOUND MATCH */ RETURN(MID);

RETURN(-1);

Основной частью каждого шага алгоритма является проверка, будет ли х меньше, больше или равен среднему элементу V[MID];

использование конструкции ELSE — IF здесь вполне естественно.

3.4. Переключатель Оператор SWITCH дает специальный способ выбора одного из многих вариантов, который заключается в проверке совпадения значения данного выражения с одной из заданных констант и соответствующем ветвлении. В главе 1 мы привели программу подсчета числа вхождений каждой цифры, символов пустых промежутков и всех остальных символов, использующую последовательность IF...ELSE IF...ELSE.

Вот та же самая программа с переключателем.

MAIN() /* COUNT DIGITS,WHITE SPACE, OTHERS */ INT C, I, NWHITE, NOTHER, NDIGIT[10];

NWHITE = NOTHER = 0;

FOR (I = 0;

I < 10;

I++) Б.В. Керниган, Д.М. Ричи. Язык С.

NDIGIT[I] = 0;

WHILE((C= GETCHAR()) != EOF) SWITCH (C) CASE '0':

CASE '1':

CASE '2':

CASE '3':

CASE '4':

CASE '5':

CASE '6':

CASE '7':

CASE '8':

CASE '9':

NDIGIT[C-'0']++;

BREAK;

CASE ' ':

CASE '\N':

CASE '\T':

NWHITE++;

BREAK;

DEFAULT :

NOTHER++;

BREAK;

PRINTF("DIGITS =");

FOR (I = 0;

I < 10;

I++) PRINTF(" %D", NDIGIT[I]);

PRINTF("\NWHITE SPACE = %D, OTHER = %D\N", NWHITE, NOTHER);

Переключатель вычисляет целое выражение в круглых скобках (в данной программе — значение символа с) и сравнивает его значение со всеми случаями (CASE). Каждый случай должен быть помечен либо целым, либо символьной константой, либо константным выражением. Если значение константного выраже ния, стоящего после вариантного префикса CASE, совпадает со значением целого выражения, то выполнение начинается с этого случая. Если ни один из случаев не подходит, то выполняется оператор после префикса DEFAULT. Префикс DEFAULT является необязательным, если его нет, и ни один из случаев не подходит, то вообще Б.В. Керниган, Д.М. Ричи. Язык С.

никакие действия не выполняются. Случаи и выбор по умолчанию могут располагаться в любом порядке. Все случаи должны быть различными.

Оператор BREAK приводит к немедленному выходу из переключателя. Поскольку случаи служат только в качестве меток, то если вы не предпримите явных действий после выполнения операторов, соответствующих одному случаю, вы провалитесь на следующий случай. Операторы BREAK и RETURN являются самым обычным способом выхода из переключателя. Как мы обсудим позже в этой главе, оператор BREAк можно использовать и для немедленного выхода из операторов цикла WHILE, FOR и DO.

Проваливание сквозь случаи имеет как свои достоинства, так и недостатки. К положительным качествам можно отнести то, что оно позволяет связать несколько случаев с одним действием, как было с пробелом, табуляцией и новой строкой в нашем примере. Но в то же время оно обычно приводит к необходимости заканчивать каждый случай оператором BREAK, чтобы избежать перехода к следующему случаю. Проваливание с одного случая на другой обычно бывает неустойчивым, так как оно склонно к расщеплению при модификации программы. За исключением, когда одному вычислению соответствуют несколько меток, проваливание следует использовать умеренно.

Заведите привычку ставить оператор BREAK после последнего случая (в данном примере после DEFAULT), даже если это не является логически необходимым. В один прекрасный день, когда вы добавите в конец еще один случай, эта маленькая мера предосторожности избавит вас от неприятностей.

Упражнение 3-1.

Напишите программу для функции EXPAND(S, T), которая копирует строку S в т, заменяя при этом символы табуляции и новой строки на видимые условные последовательности, как \N и \т. используйте переключатель.

3.5. Циклы — WHILE и FOR Мы уже сталкивались с операторами цикла WHILE и FOR. Вконструкции WHILE (выражение) оператор вычисляется выражение. Если его значение отлично от нуля, то выполняется оператор и выражение вычисляется снова. Этот цикл продолжается до тех пор, пока значение выражения не станет нулем, после чего выполнение программы продолжается с места после оператора.

Оператор FOR (выражение 1;

выражение 2;

выражение 3) оператор эквивалентен последовательности выражение 1;

WHILE (выражение 2) оператор выражение 3;

Б.В. Керниган, Д.М. Ричи. Язык С.

Грамматически все три компонента в FOR являются выражениями. наиболее распространенным является случай, когда выражение 1 и выражение 3 являются присваиваниями или обращениями к функциям, а выражение 2 — условным выражением. любая из трех частей может быть опущена, хотя точки с запятой при этом должны оставаться. Если отсутствует выражение 1 или выражение 3, то оно просто выпадает из расширения. Если же отсутствует проверка, выражение 2, то считается, как будто оно всегда истинно, так что FOR (;

;

)...

является бесконечным циклом, о котором предполагается, что он будет прерван другими средствами (такими как BREAK или RETURN).

Использовать ли WHILE или FOR — это, в основном дело вкуса. Например в WHILE ((C = GETCHAR()) == ' ' \!\! C == '\N' \!\! C == '\T') ;

/* SKIP WHITE SPACE CHARACTERS */ нет ни инициализации, ни реинициализации, так что цикл WHILе выглядит самым естественным.

Цикл FOR, очевидно, предпочтительнее там, где имеется простая инициализация и реинициализация, поскольку при этом управляющие циклом операторы наглядным образом оказываются вместе в начале цикла. Это наиболее очевидно в конструкции FOR (I = 0;

I < N;

I++) которая является идиомой языка "C" для обработки первых N элементов массива, аналогичной оператору цикла DO в фортране и PL/1. Аналогия, однако, не полная, так как границы цикла могут быть изменены внутри цикла, а управляющая переменная сохраняет свое значение после выхода из цикла, какова бы ни была причина этого выхода. Поскольку компонентами FOR могут быть произвольные выражения, они не ограничиваются только арифметическими прогрессиями. Тем не менее является плохим стилем включать в FOR вычисления, которые не относятся к управлению циклом, лучше поместить их в управляемые цикломоператоры.

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

он допускает присутствие в начале символов пустых промежутков и знака + или -. (В главе 4 приведена функция ATOF, которая выполняет то же самое преобразование для чисел с плавающей точкой).

Общая схема программы отражает форму поступающих данных:

- пропустить пустой промежуток, если он имеется - извлечь знак, если он имеется Б.В. Керниган, Д.М. Ричи. Язык С.

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

ATOI(S) /* CONVERT S TO INTEGER */ CHAR S[];

INTI, N, SIGN;

FOR(I=0;

S[I]==' ' \!\!

S[I]=='\N' \!\! S[I]=='\T';

I++) ;

/* SKIPWHITESPACE*/ SIGN = 1;

IF(S[I] == '+' \!\! S[I] == '-') /* SIGN */ SIGN = (S[I++]=='+')? 1 : — 1;

FOR( N = 0;

S[I] >= '0' && S[I] <= '9';

I++) N=10* N+S[I] — '0';

RETURN(SIGN * N);

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

SHELL(V, N) /* SORT V[0]...V[N-1] INTO INCREASING ORDER */ INT V[], N;

INT GAP, I, J, TEMP;

FOR (GAP = N/2;

GAP > 0;

GAP /= 2) FOR (I = GAP;

I < N;

I++) FOR (J=I-GAP;

J>=0 && V[J]>V[J+GAP];

J-=GAP) TEMP = V[J];

V[J] = V[J+GAP];

V[J+GAP] = TEMP;

Б.В. Керниган, Д.М. Ричи. Язык С.

Здесь имеются три вложенных цикла. Самый внешний цикл управляет интервалом между сравниваемыми элементами, уменьшая его от N/2 вдвое при каждом проходе, пока он не станет равным нулю. Средний цикл сравнивает каждую пару элементов, разделенных на величину интервала;

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

Последней операцией языка "C" является запятая ",", которая чаще всего используется в операторе FOR. Два выражения, разделенные запятой, вычисляются слева направо, причем типом и значением результата являются тип и значение правого операнда. Таким образом, в различные части оператора FOR можно включить несколько выражений, например, для параллельного изменения двух индексов. Это иллюстрируется функцией REVERSE(S), которая располагает строку S в обратном порядке на том же месте.

REVERSE(S) /* REVERSE STRING S IN PLACE */ CHAR S[];

INT C, I, J;

FOR(I = 0, J = STRLEN(S) — 1;

I < J;

I++, J--) C= S[I];

S[I] = S[J];

S[J] = C;

Запятые, которые разделяют аргументы функций, переменные в описаниях и т.д., не имеют отношения к операции запятая и не обеспечивают вычислений слева направо.

Упражнение 3-2.

Составьте программу для функции EXPAND(S1,S2), которая расширяет сокращенные обозначения вида а-Z из строки S1 в эквивалентный полный список авс...XYZ в S2. Допускаются сокращения для строчных и прописных букв и цифр.

Будьте готовы иметь дело со случаями типа а-в-с, а-Z0-9 и -а-Z. (Полезное соглашение состоит в том, что символ -, стоящий в начале или конце, воспринимается буквально).

3.6. Цикл DO — WHILE Как уже отмечалось в главе 1, циклы WHILE и FOR обладают тем приятным свойством, что в них проверка окончания осуществляется в начале, а не в конце цикла. Третий оператор цикла языка "C", DO-WHILE, проверяет условие окончания в конце, после каждого прохода через тело цикла;

тело цикла всегда выполняется по крайней мере один раз. Синтаксис этого оператора имеет вид:

DO Б.В. Керниган, Д.М. Ричи. Язык С.

оператор WHILE (выражение) Сначала выполняется оператор, затем вычисляется выражение.

Если оно истинно, то оператор выполняется снова и т.д. Если выражение становится ложным, цикл заканчивается.

Pages:     || 2 | 3 | 4 |



© 2011 www.dissers.ru - «Бесплатная электронная библиотека»

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