Бьярн Страуструп - Язык программирования C++

while (cin>>buf) value(buf)++; for (int i=0; vec[i].name; i++)

cout << vec[i].name << ": " << vec [i].val<< '\n';

}

В цикле while из стандартного входного потока cin читается по одному слову и записывается в буфер buf (см. глава 10), при этом каждый раз значение счетчика, связанного со считываемой строкой, увеличивается. Счетчик отыскивается в ассоциативном массиве vec с помощью функции find(). В цикле for печатается получившаяся таблица различных слов из cin вместе с их частотой. Имея входной поток

aa bb bb aa aa bb aa aa

программа выдает:

aa:5

bb:3

Спомощью шаблонного класса и перегруженной операции [] ($$8.8) достаточно просто довести массив из этого примера до настоящего ассоциативного массива.

2.4ЛИТЕРАЛЫ

ВС++ можно задавать значения всех основных типов: символьные константы, целые константы и константы с плавающей точкой. Кроме того, нуль (0) можно использовать как значение указателя произвольного типа, а символьные строки являются константами типа char[]. Есть возможность

определить символические константы. Символическая константа - это имя, значение которого в его области видимости изменять нельзя. В С++ символические константы можно задать тремя способами: (1) добавив служебное слово const в определении, можно связать с именем любое значение произвольного типа; (2) множество целых констант можно определить как перечисление; (3) константой является имя массива или функции.

2.4.1 Целые константы

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

0 1234 976 12345678901234567890

Десятичная константа имеет тип int, если она умещается в память, отводимую для int, в противном случае ее тип long. Транслятор должен предупреждать о константах, величина которых превышает выбранный формат представления чисел. Константа, начинающаяся с нуля, за которым следует x (0x), является шестнадцатеричным числом (с основанием 16), а константа, которая начинающаяся с нуля, за которым следует цифра, является восьмеричным числом (с основанием 8). Приведем примеры восьмеричных констант:

Их десятичные эквиваленты равны соответственно: 0, 2, 63, 83. В шестнадцатеричной записи эти константы выглядят так:

Буквы a, b, c, d, e и f или эквивалентные им заглавные буквы используются для представления чисел 10, 11, 12, 13, 14 и 15, соответственно. Восьмеричная и шестнадцатеричная формы записи наиболее подходят для задания набора разрядов, а использование их для обычных чисел может дать неожиданный эффект. Например, на машине, в которой int представляется как 16-разрядное число в дополнительном коде, 0xffff есть отрицательное десятичное число -1. Если бы для представления целого использовалось большее число разрядов, то это было бы числом 65535.

61

Окончание U может использоваться для явного задания констант типа unsigned. Аналогично, окончание L явно задает константу типа long. Например:

void f(int);

void f(unsigned int); void f(long int); void g()

{

}

2.4.2 Константы с плавающей точкой

Константы с плавающей точкой имеют тип double. Транслятор должен предупреждать о таких константах, значение которых не укладывается в формат, выбранный для представления чисел с плавающей точкой. Приведем примеры констант с плавающей точкой:

Отметим, что внутри константы с плавающей точкой не должно быть пробелов. Например, 65.43 e-21 не является константой с плавающей точкой, транслятор распознает это как четыре отдельные лексемы:

65.43 e - 21

что вызовет синтаксическую ошибку. Если нужна константа с плавающей точкой типа float, то ее можно получить, используя окончание f:

3.14159265f 2.0f 2.997925f

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

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

Несмотря на их вид, все эти комбинации задают один символ. Тип символьной константы - char. Можно также задавать символ с помощью восьмеричного числа, представленного одной, двумя или тремя восьмеричными цифрами (перед цифрами идет \) или с помощью шестнадцатеричного числа (перед

62

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

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

2.4.4 Строки

Строка - это последовательность символов, заключенная в двойные кавычки:

"это строка"

Каждая строка содержит на один символ больше, чем явно задано: все строки оканчиваются нулевым символом ('\0'), имеющим значение 0. Поэтому

sizeof("asdf")==5;

Типом строки считается "массив из соответствующего числа символов", поэтому тип "asdf" есть char[5]. Пустая строка записывается как "" и имеет тип char[1]. Отметим, что для любой строки s выполняется strlen(s)==sizeof(s)-1, поскольку функция strlen() не учитывает завершающий символ '\0'.

Внутри строки можно использовать для представления невидимых символов специальные комбинации с \. В частности, в строке можно задать сам символ двойной кавычки " или символ \. Чаще всего из таких символов оказывается нужным символ конца строки '\n', например:

cout << "звуковой сигнал в конце сообщения\007\n"

Здесь 7 - это значение в ASCII символа BEL (сигнал), который в переносимом виде обозначается как \a. Нет возможности задать в строке "настоящий" символ конца строки:

"это не строка, а синтаксическая ошибка"

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

char alpha[] = "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

Подобные, подряд идущие, строки будут объединяться в одну, поэтому массив alpha можно эквивалентным образом инициализировать с помощью одной строки:

"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";

В строке можно задавать символ '\0', но большинство программ не ожидает после него встречи с какими-либо еще символами. Например, строку "asdf\000hjkl" стандартные функции strcpy() и strlen() будут рассматривать как строку "asdf".

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

2.4.5 Нуль

Нуль (0) имеет тип int. Благодаря стандартным преобразованиям ($$R.4) 0 можно использовать как

63

константу целого типа, или типа с плавающей точкой, или типа указателя. Нельзя разместить никакой объект, если вместо адреса указан 0. Какой из типов нуля использовать, определяется контекстом. Обычно (но необязательно) нуль представляется последовательностью разрядов "все нули" подходящей длины.

2.5 Поименованные константы

Добавив к описанию объекта служебное слово const, можно превратить этот объект из переменной в константу, например:

const int model = 90;

const int v[] = { 1, 2, 3, 4 };

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

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

const char* peek(int i) // вернуть указатель на строку-константу

{

return hidden[i];

}

Приведенную функцию можно было бы использовать для передачи строки, защищенной от записи, в другую программу, где она будет читаться. Вообще говоря, транслятор может воспользоваться тем фактом, что объект является const, для различных целей (конечно, это зависит от "разумности" транслятора). Самое очевидное - это то, что для константы не нужно отводить память, поскольку ее значение известно транслятору. Далее, инициализатор для константы, как правило (но не всегда) является постоянным выражением, которое можно вычислить на этапе трансляции. Однако, для массива констант обычно приходится отводить память, поскольку в общем случае транслятор не знает, какой элемент массива используется в выражении. Но и в этом случае на многих машинах возможна оптимизация, если поместить такой массив в защищенную от записи память.

Задавая указатель, мы имеем дело с двумя объектами: с самим указателем и с указуемым объектом. Если в описании указателя есть "префикс" const, то константой объявляется сам объект, но не указатель на него, например:

Чтобы описать как константу сам указатель, а не указуемый объект, нужно использовать операцию * перед const. Например:

Чтобы сделать константами и указатель, и объект, надо оба объявить const, например:

Объект может быть объявлен константой при обращении к нему с помощью указателя, и в то же время быть изменяемым, если обращаться к нему другим способом. Особенно это удобно использовать для параметров функции. Описав параметр-указатель функции как const, мы запрещаем изменять в ней указуемый объект, например:

char* strcpy(char* p, const char* q); // не может изменять *q

64

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

2.5.1. Перечисления

Есть способ связывания имен с целыми константами, который часто более удобен, чем описание с const. Например:

enum { ASM, AUTO, BREAK };

Здесь определены три целых константы, которые называются элементами перечисления, и им присвоены значения. Поскольку по умолчанию значения элементов перечисления начинаются с 0 и идут в возрастающем порядке, то приведенное перечисление эквивалентно определениям:

const ASM = 0; const AUTO = 1; const BREAK = 2;

Перечисление может иметь имя, например:

enum keyword { ASM, AUTO, BREAK };

Имя перечисления становится новым типом. С помощью стандартных преобразований тип перечисления может неявно приводиться к типу int. Обратное преобразование (из типа int в перечисление) должно быть задано явно. Например:

void f()

{

keyword k = ASM; int i = ASM;

}

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

keyword key; switch (key) {

case ASM:

// выполнить что-либо break;

case BREAK:

// выполнить что-либо break;

}

транслятор может выдать предупреждение, поскольку из трех возможных значений типа keyword используются только два. Значения элементов перечисления можно задавать и явно. Например:

enum int16 { sign=0100000,

65

most_significant=040000, least_significant=1

};

Задаваемые значения необязательно должны быть различными, положительными и идти в возрастающем порядке.

2.6.Экономия памяти

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

количество памяти:

[1] паковать в байты переменные с малыми значениями; [2] использовать одну и ту же память для хранения разных объектов в разное время.

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

2.6.1 Поля

Кажется расточительным использовать для признака, принимающего только два значения ( например: да, нет) тип char, но объект типа char является в С++ наименьшим объектом, который может независимо размещаться в памяти. Однако, есть возможность собрать переменные с малым диапазоном значений воедино, определив их как поля структуры. Член структуры является полем, если в его определении после имени указано число разрядов, которое он должен занимать. Допустимы безымянные поля. Они не влияют на работу с поименованными полями, но могут улучшить размещение полей в памяти для конкретной машины:

unsigned non_resident : 1;

};

Приведенная структура описывает разряды нулевого регистра состояния DEC PDP11/45 (предполагается, что поля в слове размещаются слева направо). Этот пример показывает также другое возможное применение полей: давать имена тем частям объекта, размещение которых определено извне. Поле должно иметь целый тип ($$R.3.6.1 и $$R.9.6), и оно используется аналогично другим объектам целого типа. Но есть исключение: нельзя брать адрес поля. В ядре операционной системы или в отладчике тип sreg мог бы использоваться следующим образом:

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

66

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

2.6.2. Объединения

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

};

void print_entry(entry* p)

{

switch(p->type) { case 's':

cout << p->string_value; break;

case 'i':

cout << p->int_value; break;

default:

cerr << "type corrupted\n"; break;

}

}

Поскольку переменные string_value и int_value никогда не могут использоваться одновременно, очевидно, что часть памяти пропадает впустую. Это можно легко исправить, описав обе переменные как члены объединения, например, так:

struct entry { char* name; char type; union {

Теперь гарантируется, что при выделении памяти для entry члены string_value и int_value будут размещаться с одного адреса, и при этом не нужно менять все части программы, работающие с entry. Из этого следует, что все члены объединения вместе занимают такой же объем памяти, какой занимает наибольший член объединения.

Надежный способ работы с объединением заключается в том, чтобы выбирать значение с помощью того же самого члена, который его записывал. Однако, в больших программах трудно гарантировать, что объединение используется только таким способом, а в результате использования не того члена обЪединения могут возникать трудно обнаруживаемые ошибки. Но можно встроить объединение в такую структуру, которая обеспечит правильную связь между значением поля типа и текущим типом члена объединения ($$5.4.6).

Иногда объединения используют для "псевдо-преобразований" типа (в основном на это идут программисты, привыкшие к языкам, в которых нет средств преобразования типов, и в результате приходится обманывать транслятор). Приведем пример такого "преобразования" int в int* на машине VAX, которое достигается простым совпадением разрядов:

struct fudge { union {

67

В действительности это вовсе не преобразование типа, т.к. на одних машинах int и int* занимают разный объем памяти, а на других целое не может размещаться по адресу, задаваемому нечетным числом. Такое использование объединений не является переносимым, тогда как существует переносимый способ задания явного преобразования типа ($$3.2.5).

Иногда объединения используют специально, чтобы избежать преобразования типов. Например, можно использовать fudge, чтобы узнать, как представляется указатель 0:

Объединению можно дать имя, то есть можно сделать его полноправным типом. Например, fudge можно описать так:

union fudge { int i; int* p;

};

и использовать (некорректно) точно так же, как и раньше. Вместе с тем, поименованные объединения можно использовать и вполне корректным и оправданным способом (см. $$5.4.6).

2.7 Упражнения

1. (*1) Запустить программу "Hello, world" (см. $$1.3.1).

2.(*1) Для каждого описания из $$2.1 сделать следующее: если описание не является определением, то написать соответствующее определение; если же описание является определением, написатьдля него описание, которое не являлось бы одновременно и определением.

3.(*1) Напишите описания следующих объектов: указателя на символ; массива из 10 целых; ссылки на массив из 10 целых; указателя на массив символьных строк; указателя на указатель на символ; целогоконстанты; указателя на целое-константу; константного указателя на целое. Описания снабдить инициализацией.

4.(*1.5) Напишите программу, которая печатает размеры основных типов и типа указателя. Используйте операцию sizeof.

5.(*1.5) Напишите программу, которая печатает буквы от 'a' до 'z' и цифры от '0' до '9' и их целые значения. Проделайте то же самое для других видимых символов. Проделайте это, используя шестнадцатеричную запись.

6.(*1) Напечатайте последовательность разрядов представления указателя 0 на вашей машине. Подсказка: см.$$2.6.2.

7.(*1.5) Напишите функцию, печатающую порядок и мантиссу параметра типа double.

8.(*2) Каковы на используемой вами машине наибольшие и наименьшие значения следующих типов: char, short,int,long, float, double, long double, unsigned, char*, int* и void*? Есть ли какие-то особые ограничения на эти значения? Например, может ли int* быть нечетным целым? Как выравниваются в памяти объекты этих типов? Например, может ли целое иметь нечетный адрес?

9.(*1) Какова максимальная длина локального имени, которое можно использовать в вашей реализации С++ ? Какова максимальная длина внешнего имени? Есть ли какие-нибудь ограничения на символы, которые можно использовать в имени?

10. (*1) Напишите функцию, которая меняет местами значения двух целых. В качестве типа параметров используйте int*. Напишите другую функцию с тем же назначением, используя в качестве типа параметров int&.

68

69

ГЛАВА 3. ВЫРАЖЕНИЯ И ОПЕРАТОРЫ

"Но с другой стороны не следует забывать про эффективность" (Джон Бентли)

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

3.1 Калькулятор

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

r=2.5

area=pi*r*r

(здесь pi имеет предопределенное значение). Тогда программа калькулятора выдаст:

2.5

19.635

Результат вычислений для первой входной строки равен 2.5, а результат для второй строки - это

19.635.

Программа калькулятора состоит из четырех основных частей: анализатора, функции ввода, таблицы имен и драйвера. По сути – это транслятор в миниатюре, в котором анализатор проводит синтаксический анализ, функция ввода обрабатывает входные данные и проводит лексический анализ, таблица имен хранит постоянную информацию, нужную для работы, а драйвер выполняет инициализацию, вывод результатов и обработку ошибок. К такому калькулятору можно добавить много других полезных возможностей, но программа его и так достаточно велика (200 строк), а введение новых возможностей только увеличит ее объем, не давая дополнительной информации для изучения С++.

3.1.1 Анализатор

Грамматика языка калькулятора определяется следующими правилами:

список-выражений:

выражение PRINT // PRINT - это '\n' или ';'

выражение PRINT список-выражений

выражение: выражение + терм выражение - терм терм

терм:

терм / первичное терм * первичное первичное

70