Бьерн Страуструп (947334), страница 15

Просмтор этого файла доступен только зарегистрированным пользователям. Но у нас супер быстрая регистрация: достаточно только электронной почты!

Текст из файла (страница 15)

struct entry {

char* name;

char type;

char* string_value; // используется если type == 's'

int int_value; // используется если type == 'i'

};

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 {

char* string_value; // используется если type == 's'

int int_value; // используется если type == 'i'

};

};

Теперь гарантируется, что при выделении памяти для entry члены

string_value и int_value будут размещаться с одного адреса, и

при этом не нужно менять все части программы, работающие с entry.

Из этого следует, что все члены объединения вместе занимают такой же

объем памяти, какой занимает наибольший член объединения.

Надежный способ работы с объединением заключается в том, чтобы

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

Однако, в больших программах трудно гарантировать, что объединение

используется только таким способом, а в результате использования

не того члена обЪединения могут возникать трудно обнаруживаемые ошибки.

Но можно встроить объединение в такую структуру, которая обеспечит

правильную связь между значением поля типа и текущим типом члена

объединения ($$5.4.6).

Иногда объединения используют для "псевдопреобразований" типа

(в основном на это идут программисты, привыкшие к языкам, в которых

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

транслятор). Приведем пример такого "преобразования" int в int*

на машине VAX, которое достигается простым совпадением разрядов:

struct fudge {

union {

int i;

int* p;

};

};

fudge a;

a.i = 4095;

int* p = a.p; // некорректное использование

В действительности это вовсе не преобразование типа, т.к. на одних

машинах int и int* занимают разный объем памяти, а на других целое

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

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

существует переносимый способ задания явного преобразования

типа ($$3.2.5).

Иногда объединения используют специально, чтобы избежать

преобразования типов. Например, можно использовать fudge, чтобы

узнать, как представляется указатель 0:

fudge.p = 0;

int i = fudge.i; // i необязательно должно быть 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&.

11. (*1) Каков размер массива str в следующем примере:

char str[] = "a short string";

Какова длина строки "a short string"?

12. (*1.5) Составьте таблицу из названий месяцев года и числа дней

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

это дважды: один раз - используя массивы для названий месяцев

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

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

13. (*1) С помощью typedef определите типы: unsigned char, константный

unsigned char, указатель на целое, указатель на указатель на

символ, указатель на массив символов, массив из 7 указателей

на целое, указатель на массив из 7 указателей на целое и массив из

8 массивов из 7 указателей на целое.

14. (*1) Определить функции f(char), g(char&) и h(const char&) и

вызвать их, используя в качестве параметров 'a', 49, 3300, c, uc, и

sc, где c - char, uc - unsigned char и sc - signed char. Какой

вызов является законным? При каком вызове транслятору придется

завести временную переменную?

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

"Но с другой стороны не следует

забывать про эффективность"

(Джон Бентли)

С++ имеет сравнительно небольшой набор операторов, который позволяет

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

работы с данными. Основные их возможности показаны в этой главе на одном

завершенном примере. Затем приводится сводка выражений, и подробно

обсуждаются операции преобразования типа и размещение в свободной памяти.

Далее дана сводка операторов, а в конце главы обсуждается выделение

текста пробелами и использование комментариев.

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

Мы познакомимся с выражениями и операторами на примере программы

калькулятора. Калькулятор реализует четыре основных арифметических

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

В качестве упражнения предлагается добавить к калькулятору

переменные. Допустим, входной поток имеет вид:

r=2.5

area=pi*r*r

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

выдаст:

2.5

19.635

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

для второй строки - это 19.635.

Программа калькулятора состоит из четырех основных частей:

анализатора, функции ввода, таблицы имен и драйвера. По сути - это

транслятор в миниатюре, в котором анализатор проводит синтаксический

анализ, функция ввода обрабатывает входные данные и проводит

лексический анализ, таблица имен хранит постоянную информацию, нужную

для работы, а драйвер выполняет инициализацию,

вывод результатов и обработку ошибок. К такому калькулятору можно

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

достаточно велика (200 строк), а введение новых возможностей

только увеличит ее объем, не давая дополнительной

информации для изучения С++.

3.1.1 Анализатор

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

программа:

END // END - это конец ввода

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

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

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

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

выражение:

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

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

терм

терм:

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

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

первичное

первичное:

NUMBER // число с плавающей запятой в С++

NAME // имя в языке С++ за исключением '_'

NAME = выражение

- первичное

( выражение )

Иными словами, программа есть последовательность строк, а каждая

строка содержит одно или несколько выражений, разделенных точкой

с запятой. Основные элементы выражения - это числа, имена и

операции *, /, +, - (унарный и бинарный минус) и =. Имена

необязательно описывать до использования.

Для синтаксического анализа используется метод, обычно называемый

рекурсивным спуском. Это распространенный и достаточно очевидный

метод. В таких языках как С++, то есть в которых операция вызова

не сопряжена с большими накладными расходами, это метод эффективен.

Для каждого правила грамматики имеется своя функция, которая вызывает

другие функции. Терминальные символы (например, END, NUMBER, + и -)

распознаются лексическим анализатором get_token(). Нетерминальные

символы распознаются функциями синтаксического анализатора expr(),

term() и prim(). Как только оба операнда выражения или подвыражения

стали известны, оно вычисляется. В настоящем трансляторе в этот

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

Анализатор использует для ввода функцию get_token().

Значение последнего вызова get_token() хранится в глобальной переменной

curr_tok. Переменная curr_tok принимает значения элементов перечисления

token_value:

enum token_value {

NAME, NUMBER, END,

PLUS='+', MINUS='-', MUL='*', DIV='/',

PRINT=';', ASSIGN='=', LP='(', RP=')'

};

token_value curr_tok;

Для всех функций анализатора предполагается, что get_token() уже

была вызвана, и поэтому в curr_tok хранится следующая лексема,

подлежащая анализу. Это позволяет анализатору заглядывать на одну

лексему вперед. Каждая функция анализатора всегда читает

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

для которого она вызывалась. Каждая функция анализатора вычисляет

"свое" выражение и возвращает его результат. Функция expr() обрабатывает

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

распознанные термы складываются или вычитаются:

double expr() // складывает и вычитает

{

double left = term();

for(;;) // ``вечно''

switch(curr_tok) {

case PLUS:

get_token(); // случай '+'

left += term();

break;

case MINUS:

get_token(); // случай '-'

left -= term();

break;

default:

return left;

}

}

Сама по себе эта функция делает немного. Как принято в

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

вызывая другие функции. Отметим, что выражения вида 2-3+4

вычисляются как (2-3)+4, что предопределяется правилами грамматики.

Непривычная запись for(;;) - это стандартный способ задания бесконечного

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

оператора for, и альтернативой ей может служить оператор while(1).

Оператор switch выполняется повторно до тех пор, пока не

перестанут появляться операции + или - , а тогда по умолчанию выполняется

оператор return (default).

Характеристики

Список файлов книги