2.4.1 Целые Константы
Целые константы предстают в четырех обличьях: десятичные, восьмеричные, шестнадцатеричные константа и символьные константы. Десятичные используются чаще всего и выглядят так, как можно было бы ожидать:
0 1234 976 12345678901234567890
Десятичная константа имеет тип int, при условии, что она влезает в int, в противном случае ее тип long. Компилятор должен предупреждать о константах, которые слишком длинны для представления в машине.
Константа, которая начинается нулем за которым идет x (0 x), является шестнадцатеричным числом (с основанием 16), а константа, которая начинается нулем за которым идет цифра, является восьмеричным числом (с основанием 8). Вот примеры восьмеричных констант:
0 02 077 0123
их десятичные эквиваленты – это 0, 2, 63, 83. В шестнадцатиричной записи эти константы выглядят так:
0x0 0x2 0x3f 0x53
Буквы a, b, c, d, e и f, или их эквиваленты в верхнем регистре, используются для представления чисел 10, 11, 12, 13, 14 и 15, соответственно. Восьмеричная и шестнадцатеричная записи наиболее полезны для записи набора битов применение этих записей для выражения обычных чисел может привести к неожиданностям. Например, на машине, где int представляется как двоичное дополнительное шестнадцатеричное целое, 0xffff является отрицательным десятичным числом -1; если бы для представления целого использовалось большее число битов, то оно было бы числом 65535.
2.4.2 Константы с Плавающей Точкой
Константы с плавающей точкой имеют тип double. Как и в предыдущем случае, компилятор должен предупреждать о константах с плавающей точкой, которые слишком велики, чтобы их моно было представить. Вот некоторые константы с плавающей точкой:
1.23 .23 0.23 1. 1.0 1.2e10 1.23e-15
Заметьте, что в середине константы с плавающей точкой не может встречаться пробел. Например, 65.43 e-21 является не константой с плавающей точкой, а четырьмя отдельными лексическими символами (лексемами):
65.43 e – 21
и вызовет синтаксическую ошибку.
Если вы хотите иметь константу константа с плавающей точкой; типа float, вы можете определить ее так (#2.4.6):
const float pi = 3.14159265;
2.4.3 Символьные Константы
Хотя в С++ и нет отдельного символьного типа данных, точнее, символ может храниться в целом типе, в нем для символов имеется специальная и удобная запись. Символьная константа – это символ, заключенный в одинарные кавычки; например, 'a' или '0'. Такие символьные константы в действительности являются символическими константами для целого значения символов в наборе символов той машины, на которой будет выполняться программа (который не обязательно совпадает с набором символов, применяемом на том компьютере, где программа компилируется). Поэтому, если вы выполняетесь на машине, использующей набор символов ASCII, то значением '0' будет 48, но если ваша машина использует EBCDIC набор символов, то оно будет 240. Употребление символьных констант вместо десятичной записи делает программу более переносимой. Несколько символов также имеют стандартные имена, в которых обратная косая \ используется как escape-символ:
'\b', возврат назад '\f', перевод формата '\n', новая строка '\r', возврат каретки '\t', горизонтальная табуляция '\v', вертикальная табуляция '\\', \ обратная косая (обратный слеш) '\'', одинарная кавычка ' '\"', двойная кавычка " '\0', null, пустой символ, целое значение 0
Вопреки их внешнему виду каждое является одним символом. Можно также представлять символ одно-, два или трехзначным восьмеричным числом (символ \, за которым идут восьмеричные цифры), или одно-, два или трехзначным шестнадцатеричным числом (\x, за которым идут шестнадцатеричные цифры). Например:
'\6' '\x6' 6 ASCII ack '\60' '\x30' 48 ASCII '0' '\137' '\x05f' 95 ASCII '_'
Это позволяет представлять каждый символ из машинного набора символов, и в частности вставлять такие символы в символьные строки (см. следующий раздел). Применение числовой записи для символов делает программу непереносимой между машинами с различными наборами символов.
2.4.4 Строки
Строковая константа – это последовательность символов, заключенная в двойные кавычки "
«это строка»
Каждая строковая константа содержит на один символ больше, чем кажется; все они заканчиваются пустым символом '\0' со значением 0. Например:
sizeof(«asdf»)==5;
Строка имеет тип «вектор из соответствующего числа символов», поэтому «asdf» имеет тип char[5]. Пустая строка записывается "" (и имеет тип char[1]). Заметьте, что для каждой строки s strlen(s)==sizeof(s)-1, поскольку strlen() не учитывает завершающий 0.
Соглашение о представлении неграфических символов с обратной косой можно использовать также и внутри строки. Это дает возможность представлять двойные кавычки и escape-символ. Самым обычным символом этого рода является, безусловно, символ новой строки '\n'. Например:
cout «„ «гудок в конце сообщения\007\n“
где 7 – значение ASKII символа bel (звонок).
В строке невозможно иметь «настоящую» новую строку:
«это не строка, а синтаксическая ошибка»
Однако в строке может стоять обратная косая, сразу после которой идет новая строка; и то, и другое будет проигнорировано. Например:
cout «„ «здесь все \ ok“
напечатает
здесь все ok
Новая строка, перед которой идет escape (обратная косая), не приводит к появлению в строке новой строки, это просто договоренность о записи.
В строке можно иметь пустой символ, но большинство программ не будет предполагать, что есть символы после него. Например, строка «asdf\000hjkl» будет рассматриваться стандартными функциями, вроде strcpy() и strlen(), как «asdf».
Вставляя численную константу в строку с помощью восьмеричной или шестнадцатеричной записи благоразумно всегда использовать число из трех цифр. Читать запись достаточно трудно и без необходимости беспокоиться о том, является ли символ после константы цифрой или нет. Разберите эти примеры:
char v1[] = «a\x0fah\0129»; // 'a' '\xfa' 'h' '\12' '9' char v2[] = «a\xfah\129»; // 'a' '\xfa' 'h' '\12' '9' char v3[] = «a\xfad\127»; // 'a' '\xfad' '\127'
Имейте в виду, что двухзначной шестнадцатеричной записи на машинах с 9-битовым байтом будет недостаточно.
2.4.5 Ноль
Ноль можно употреблять как константу любого целого, плавающего или указательного типа. Никакой объект не размещается по адресу 0. Тип нуля определяется контекстом. Обычно (но не обязательно) он представляется набором битов все-нули соответствующей длины.
2.4.6 Const
Ключевое слово const может добавляться к описанию объекта, чтобы сделать этот объект константой, а не переменной. Например:
const int model = 145; const int v[] = (* 1, 2, 3, 4 *);
Поскольку константе ничего нельзя присвоить, она должна быть инициализирована. Описание чего-нибудь как const гарантирует, что его значение не изменится в области видимости:
model = 145; // ошибка model++; // ошибка
Заметьте, что const изменяет тип, то есть ограничивает способ использования объекта, вместо того, чтобы задавать способ размещения константы. Поэтому например вполне разумно, а иногда и полезно, описывать функцию как возвращающую const:
const char* peek(int i) (* return private[i]; *)
Функцию вроде этой можно было бы использовать для того, чтобы давать кому-нибудь читать строку, которая не может быть затерта или переписана (этим кем-то).
С другой стороны, компилятор может несколькими путями воспользоваться тем, что объект является константой (конечно, в зависимости от того, насколько он сообразителен). Самое очевидное – это то, что для константы не требуется выделять память, поскольку компилятор знает ее значение. Кроме того, инициализатор константы часто (но не всегда) является константным выражением, то есть он может быть вычислен на стадии компиляции. Однако для вектора констант обычно приходится выделять память, поскольку компилятор в общем случае не может вычислить, на какие элементы вектора сделаны ссылки в выражениях. Однако на многих машинах даже в этом случае может достигаться повышение эффективности путем размещения векторов констант в память, доступную только для чтения.
Использование указателя вовлекает два объекта: сам указатель и указываемый объект. Снабжение описания указателя «префиксом» const делает объект, но не сам указатель, константой. Например:
const char* pc = «asdf»; // указатель на константу pc[3] = 'a'; // ошибка pc = «ghjk»; // ok
Чтобы описать сам const указатель, а не указываемый объект, как константный, используется операция const*. Например:
char *const cp = «asdf»; // константный указатель cp[3] = 'a'; // ok cp = «ghjk»; // ошибка
Чтобы сделать константами оба объекта, их оба нужно описать const. Например:
const char *const cpc = «asdf»; // const указатель на const cpc[3] = 'a'; // ошибка cpc = «ghjk»; // ошибка
Объект, являющийся константой при доступе к нему через один указатель, может быть переменной, когда доступ осуществляется другими путями. Это в частности полезно для параметров функции. Посредством описания параметра указателя как const функции запрещается изменять объект, на который он указывает. Например:
char* strcpy(char* p, const char* q); // не может изменить q
Указателю на константу можно присваивать адрес переменой, поскольку никакого вреда от этого быть не может. Однако нельзя присвоить адрес константы указателю, на который не было наложено ограничение, поскольку это позволило бы изменить значение объекта. Например:
int a = 1; const c = 2; const* p1 = amp;c; // ok const* p2 = amp;a; // ok int* p3 = amp;c; // ошибка *p3 = 7; // меняет значение c
Как обычно, если тип в описании опущен, то он предполагается int.
2.4.7 Перечисления
Есть другой метод определения целых констант, который иногда более удобен, чем применение const. Например:
enum (* ASM, AUTO, BREAK *);
перечисление определяет три целых константы, называемых перечислителями, и присваивает им значения. Поскольку значения перечислителей по умолчанию присваиваются начиная с 0 в порядке возрастания, это эквивалентно записи:
const ASM = 0; const AUTO = 1; const BREAK = 2;
Перечисление может быть именованным. Например:
enum keyword (* ASM, AUTO, BREAK *);
Имя перечисления становится синонимом int, а не новым типом. Описание переменной keyword, а не просто int, может дать как программисту, так и компилятору подсказку о том, что использование преднамеренное. Например:
keyword key;
switch (key) (* case ASM: // что-то делает break; case BREAK: // что-то делает break; *)
побуждает компилятор выдать предупреждение, поскольку только два значения keyword из трех используются.
Можно также задавать значения перечислителей явно. Например:
enum int16 (* sign=0100000, // знак most_significant=040000, // самый значимый least_significant=1 // наименее значимый *);
Такие значения не обязательно должны быть различными, возрастающими или положительными.
2.5 Экономия Пространства
В ходе программирования нетривиальных разработок неизбежно наступает время, когда хочется иметь больше пространства памяти, чем имеется или отпущено. Есть два способа выжать побольше пространства из того, что доступно:
1. Помещение в байт более одного небольшого объекта и
2. Использование одного и того же пространства для хранения разных объектов в разное время.
Первого можно достичь с помощью использования полей, второго – через использование объединений. Эти конструкции описываются в следующих разделах. Поскольку обычное их применение состоит чисто в оптимизации программы, и они в большинстве случаев непереносимы, программисту следует дважды подумать, прежде чем использовать их. Часто лучше изменить способ управления данными; например, больше полагаться на динамически выделяемую память (#3.2.6) и меньше на заранее выделенную статическую память.
2.5.1 Поля
Использование char для представления двоичной переменой, например, переключателя включено/выключено, может показаться экстравагантным, но char является наименьшим объектом, который в С++ может выделяться независимо. Можно, однако, сгруппировать несколько таких крошечных переменных вместе в виде полей struct. Член определяется как поле путем указания после его имени числа битов, которые он занимает. Допустимы неименованные поля; они не влияют на смысл именованных полей, но неким машинно-зависимым образом могут улучшить размещение:
struct sreg (* unsigned enable : 1; unsigned page : 3; unsigned : 1; // неиспользуемое unsigned mode : 2; unsigned : 4: // неиспользуемое unsigned access : 1; unsigned length : 1; unsigned non_resident : 1; *)
Получилось размещение регистра 0 состояния DEC PDP11/45 (в предположении, что поля в слове размещаются слева направо). Этот пример также иллюстрирует другое основное применение полей: именовать части внешне предписанного размещения. Поле должно быть целого типа и используется как другие целые, за исключением того, что невозможно взять адрес поля. В ядре операционной системы или в отладчике тип sreg можно было бы использовать так:
sreg* sr0 = (sreg*)0777572; //... if (sr-»access) (* // нарушение доступа // чистит массив sr-»access = 0; *)
Однако применение полей для упаковки нескольких переменных в один байт не обязательно экономит пространство. Оно экономит пространство, занимаемое данными, но объем кода, необходимого для манипуляции этими переменными, на большинстве машин возрастает. Известны программы, которые значительно сжимались, когда двоичные переменные преобразовывались из полей бит в символы! Кроме того, доступ к char или int обычно намного быстрее, чем доступ к полю. Поля – это просто удобная
и краткая запись для применения логических операций с целью извлечения информации из части слова или введения информации в нее.
2.5.2 Объединения
Рассмотрим проектирование символьной таблицы, в которой каждый элемент содержит имя и значение, и значение может быть либо строкой, либо целым:
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\n“; break; *) *)
Поскольку string_value и int_value никогда не могут использоваться одновременно, ясно, что пространство пропадает впустую. Это можно легко исправить, указав, что оба они должны быть членами union. Например, так:
struct entry (* char* name; char type; union (* char* string_value; //используется если type == 's' int int_value; //используется если type == 'i' *); *);
Это оставляет всю часть программы, использующую entry, без изменений, но обеспечивает, что при размещении entry string_value и int_value имеют один и тот же адрес. Отсюда следует, что все члены объединения вместе занимают лишь столько памяти, сколько занимает наибольший член.
Использование объединений таким образом, чтобы при чтении значения всегда применялся тот член, с применением которого оно записывалось, совершенно оптимально. Но в больших программах непросто гарантировать, что объединения используются только таким образом, и из-за неправильного использования могут появляться трудно уловимые ошибки. Можно @капсулзировать объединение таким образом, чтобы соответствие между полем типа и типами членов было гарантированно правильным (#5.4.6).
Объединения иногда используют для «объединения и преобразование типа» (это делают главным образом программисты, воспитанные на языках, не обладающих средствами преобразования типов, где жульничество является необходимым). Например, это «преобразует» на VAX'е int в int*, просто предполагая побитовую эквивалентность:
struct fudge (* union (* int i; int* p; *); *);
fudge a; a.i = 4096; 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.6 Упражнения
1. (*1) Заставьте работать программу с «Hello, world» (1.1.1).
2. (*1) Для каждого описания в #2.1 сделайте следующее: Если описание не является определением, напишите для него определение. Если описание является определением, напишите для него описание, которое при этом не является определением.
3. (*1) Напишите описания для: указателя на символ; вектора из 10 целых; ссылки на вектор из 10 целых; указателя на вектор из символьных строк; указателя на указатель на символ; константного целого; указателя на константное целое; и константного указателя на целое. Каждый из них инициализируйте.
4. (*1.5) Напишите программу, которая печатает размеры основных и указательных типов. Используйте операцию sizeof.
5. (*1.5) Напишите программу, которая печатает буквы 'a'...'z' и цифры '0'...'9' и их числовые значения. Сделайте то же для остальных печатаемых символов. Сделайте то же, но используя шестнадцатиричную запись.
6. (*1) Напечатайте набор битов, которым представляется указатель 0 на вашей системе. Подсказка: #2.5.2.
7. (*1.5) Напишите функцию, печатающую порядок и мантиссу параметра типа double.
8. (*2) Каковы наибольшие и наименьшие значения, на вшей системе, следующих типов: char, short, int, long, float, double, unsigned, char*, int* и void*? Имеются ли дополнительные ограничения на принимаемые ими значения? Может ли, например, int* принимать нечетное значение? Как выравниваются в памяти объекты этих типов? Может ли, например, int иметь нечетный адрес?
9. (*1) Какое самое длинное локальное имя можно использовать в С++ программе в вашей системе? Какое самое длинное внешнее имя можно использовать в С++ программе в вашей системе? Есть ли какие-нибудь ограничения на символы, которые моно употреблять в имени?
10. (*2) Определите one следующим образом:
const one = 1;
Попытайтесь поменять значение one на 2. Определите num следующим образом:
const num[] = (* 1, 2 *);
Попытайтесь поменять значение num[1] на 2.
11. (*1) Напишите функцию, переставляющую два целых (меняющую значения). Используйте в качестве типа параметра int*. Напишите другую переставляющую функцию, использующую в качестве типа параметра int amp;.
12. (*1) Каков размер вектора str в следующем примере:
char str[] = «a short string»;
Какова длина строки «a short string»?
13. (*1.5) Определите таблицу названий месяцев года и числа дней в них. Выведите ее. Сделайте это два раза: один раз используя вектор для названий и вектор для числа дней, и один раз используя вектор структур, в каждой из которых хранится название месяца и число дней в нем.
14. (*1) С помощью typedef определите типы: беззнаковый char, константный беззнаковый char, указатель на целое, указатель на указатель на char, указатель на вектора символов, вектор из 7 целых указателей, указатель на вектор из 7 целых указателей, и вектор из 8 векторов из 7 целых указателей.
Глава 3 Выражения и Операторы
С другой стороны, мы не можем игнорировать эффективность
Джон Бентли
С++ имеет небольшой, но гибкий набор различных видов операторов для контроля потока управления в программе и богатый набор операций для манипуляции данными. С наиболее общепринятыми средствами вас познакомит один законченный пример. После него приводится резюмирующий обзор выражений и с довольно подробно описываются явное описание типа и работа со свободной памятью. Потом представлена краткая сводка операций, а в конце обсуждаются стиль выравнивания* и комментарии.
– * Нам неизвестен русскоязычный термин, эквивалентный английскому indentation. Иногда это называется отступами. (прим. перев.)
3.1 Настольный калькулятор
С операторами и выражениями вас познакомит приведенная здесь программа настольного калькулятора, предоставляющего четыре стандартные арифметические операции над числами с плавающей точкой. Пользователь может также определять переменные. Например, если вводится
r=2.5 area=pi*r*r
(pi определено заранее), то программа калькулятора напишет:
2.5 19.635
где 2.5 – результат первой введенной строки, а 19.635 – результат второй.
Калькулятор состоит из четырех основных частей: программы синтаксического разбора (parser'а), функции ввода, таблицы имен и управляющей программы (драйвера). Фактически, это миниатюрный компилятор, в котором программа синтаксического разбора производит синтаксический анализ, функция ввода осуществляет ввод и лексический анализ, в таблице имен хранится долговременная информация, а драйвер распоряжается инициализацией, выводом и обработкой ошибок. Можно было бы многое добавить в этот калькулятор, чтобы сделать его более полезным, но в существующем виде эта программа и так достаточно длинна (200 строк), и большая часть дополнительных возможностей просто увеличит текст программы не давая дополнительного понимания применения С++.
3.1.1 Программа синтаксического разбора
Вот грамматика языка, допускаемого калькулятором:
program: END // END – это конец ввода expr_list END
expr_list: expression PRINT // PRINT – это или '\n' или ';' expression PRINT expr_list
expression: expression + term expression – term term
term: term / primary term * primary primary
primary: NUMBER // число с плавающей точкой в С++ NAME // имя С++ за исключением '_' NAME = expression – primary ( expression )
Другими словами, программа есть последовательность строк. Каждая строка состоит из одного или более выражений, разделенных запятой. Основными элементами выражения являются числа, имена и операции *, /, +, – (унарный и бинарный) и =. Имена не обязательно должны описываться до использования.
Используемый метод обычно называется рекурсивным спуском это популярный и простой нисходящий метод. В таком языке, как С++, в котором вызовы функций относительно дешевы, этот метод к тому же и эффективен. Для каждого правила вывода грамматики имеется функция, вызывающая другие функции. Терминальные символы (например, 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.
– * игра слов: «for» – «forever» (навсегда). (прим. перев.)
Операции +=, -= используются для осуществления сложения и вычитания. Можно было бы не изменяя смысла программы использовать left=left+term() и left=left-term(). Однако left+= term() и left-=term() не только короче, но к тому же явно выражают подразумеваемое действие. Для бинарной операции @ выражение x@=y означает x=x@y за исключением того, что x вычисляется только один раз. Это применимо к бинарным операциям
+ – * / % amp; ! ^ «„ “»
поэтому возможны следующие операции присваивания:
+= -= *= /= %= amp;= != ^= «„= “»=
Каждая является отдельной лексемой, поэтому a+ =1 является синтаксической ошибкой из-за пробела между + и =. (% является операцией взятия по модулю; amp;,! и ^ являются побитвыми операциями И, ИЛИ и исключающее ИЛИ; «„ и “» являются операциями левого и правого сдвига). Функции term() и get_token() должны быть описаны до expr().
Как организовать программу в виде набора файлов, обсудается в Главе 4. За одним исключением все описания в данной программе настольного калькулятора можно упорядочить так, чтобы все описывалось ровно один раз и до использования. Ислючением является expr(), которая обращается к term(), котрая обращается к prim(), которая в свою очередь обращается к expr(). Этот круг надо как-то разорвать;
Описание
double expr(); // без этого нельзя
перед prim() прекрасно справляется с этим.
Функция term() аналогичным образом обрабатывает умножние и сложение:
double term() // умножает и складывает (* double left = prim();
for(;;) switch(curr_tok) (* case MUL: get_token(); // ест '*' left *= prim(); break; case DIV: get_token(); // ест '/' double d = prim(); if (d == 0) return error(«деление на 0»); left /= d; break; default: return left; *) *)
Проверка, которая делается, чтобы удостовериться в том, что нет деления на ноль, необходима, поскольку результат дления на ноль неопределен и как правило является роковым. Функция error(char*) будет описана позже. Переменная d ввдится в программе там, где она нужна, и сразу же инициализруется. Во многих языках описание может располагаться только в голове блока. Это ограничение может приводить к довольно скверному искажению стиля программирования и/или излишним ошибкам. Чаще всего неинициализированные локальные переменные являются просто признаком плохого стиля; исключением являются переменные, подлежащие инициализации посредством ввода, и пременные векторного или структурного типа, которые нельзя удобно инициализировать одними присваиваниями*. Заметьте, что = является операцией присваивания, а == операцией сравнения.
– * В языке немного лучше этого с этими исключениями тоже надо бы справляться. (прим. автора)
Функция prim, обрабатывающая primary, написана в осноном в том же духе, не считая того, что немного реальной рабты в ней все-таки выполняется, и нет нужды в цикле, поскольку мы попадаем на более низкий уровень иерархии вызовов:
double prim() // обрабатывает primary (первичные) (* switch (curr_tok) (* case NUMBER: // константа с плавающей точкой get_token(); return number_value; case NAME: if (get_token() == ASSIGN) (* name* n = insert(name_string); get_token(); n-»value = expr(); return n-»value; *) return look(name-string)-»value; case MINUS: // унарный минус get_token(); return -prim(); case LP: get_token(); double e = expr(); if (curr_tok != RP) return error(«должна быть )»); get_token(); return e; case END: return 1; default:
return error(«должно быть primary»); *) *)
При обнаружении NUMBER (то есть, константы с плавающей точкой), возвращается его значение. Функция ввода get_token() помещает значение в глобальную переменную number_value. Ипользование в программе глобальных переменных часто указывает на то, что структура не совсем прозрачна, что применялась нкоторого рода оптимизация. Здесь дело обстоит именно так. Торетически лексический символ обычно состоит из двух частей: значения, определяющего вид лексемы (в данной программе token _value), и (если необходимо) значения лексемы. У нас имеется только одна простая переменная curr_tok, поэтому для хранения значения последнего считанного NUMBER понадобилась глобальная переменная переменная number_value. Это работает только потму, что калькулятор при вычислениях использует только одно число перед чтением со входа другого.
Так же, как значение последнего встреченного NUMBER хранится в number_value, в name_string в виде символьной строки хранится представление последнего прочитанного NAME. Перед тем, как что-либо сделать с именем, калькулятор должен заглнуть вперед, чтобы посмотреть, осуществляется ли присваивание ему, или оно просто используется. В обоих случаях надо спрвиться в таблице имен. Сама таблица описывается в #3.1.3; здесь надо знать только, что она состоит из элементов вида:
