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

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

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

struct name {

char* string;

name* next;

double value;

};

Член next используется для связи записей в таблице.

Собственно таблица - это просто массив указателей на объекты типа name:

const TBLSZ = 23;

name* table[TBLSZ];

Поскольку по умолчанию все статические объекты инициализируются нулем,

такое тривиальное описание таблицы table обеспечивает также и нужную

инициализацию.

Для поиска имени в таблице функция look() использует простой

хэш-код (записи, в которых имена имеют одинаковый хэш-код,

связываются):

вместе):

int ii = 0; // хэш-код

const char* pp = p;

while (*pp) ii = ii<<1 ^ *pp++;

if (ii < 0) ii = -ii;

ii %= TBLSZ;

Иными словами, с помощью операции ^ ("исключающее ИЛИ") все символы

входной строки p поочередно добавляются к ii. Разряд в результате x^y

равен 1 тогда и только тогда, когда эти разряды в операндах x и y различны.

До выполнения операции ^ значение ii сдвигается на один разряд влево,

чтобы использовался не только один байт ii. Эти действия можно

записать таким образом:

ii <<= 1;

ii ^= *pp++;

Для хорошего хэш-кода лучше использовать операцию ^, чем +. Операция

сдвига важна для получения приемлемого хэш-кода в обоих случаях.

Операторы

if (ii < 0) ii = -ii;

ii %= TBLSZ;

гарантируют, что значение ii будет из диапазона 0...TBLSZ-1. Напомним,

что % - это операция взятия остатка. Ниже полностью приведена

функция look:

#include <string.h>

name* look(const char* p, int ins =0)

{

int ii = 0; // хэш-код

const char* pp = p;

while (*pp) ii = ii<<1 ^ *pp++;

if (ii < 0) ii = -ii;

ii %= TBLSZ;

for (name* n=table[ii]; n; n=n->next) // поиск

if (strcmp(p,n->string) == 0) return n;

if (ins == 0) error("имя не найдено");

name* nn = new name; // занесение

nn->string = new char[strlen(p)+1];

strcpy(nn->string,p);

nn->value = 1;

nn->next = table[ii];

table[ii] = nn;

return nn;

}

После вычисления хэш-кода ii идет простой поиск имени по членам

next. Имена сравниваются с помощью стандартной функции

сравнения строк strcmp(). Если имя найдено, то возвращается указатель

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

с этим именем.

Добавление нового имени означает создание нового объекта name

в свободной памяти с помощью операции new (см. $$3.2.6), его

инициализацию и включение в список имен. Последнее выполняется как

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

без проверки того, есть ли список вообще. Символьная строка имени

также размещается в свободной памяти. Функция strlen() указывает,

сколько памяти нужно для строки, операция new отводит нужную память,

а функция strcpy() копирует в нее строку. Все строковые функции

описаны в <string.h>:

extern int strlen(const char*);

extern int strcmp(const char*, const char*);

extern char* strcpy(char*, const char*);

3.1.4 Обработка ошибок

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

об обработке ошибок. Функция error просто подсчитывает число ошибок,

выдает сообщение о них и возвращает управление обратно:

int no_of_errors;

double error(const char* s)

{

cerr << "error: " << s << "\n";

no_of_errors++;

return 1;

}

Небуферизованный выходной поток cerr обычно используется именно для

выдачи сообщений об ошибках.

Управление возвращается из error() потому, что ошибки, как правило,

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

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

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

последнее. Если бы функция get_token() отслеживала номера строк, то

функция error() могла бы указывать пользователю приблизительное место

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

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

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

Завершить ее можно с помощью вызова функции exit(), которая заканчивает

работу с выходными потоками ($$10.5.1) и завершает программу,

возвращая свой параметр в качестве ее результата.

Более радикальный способ завершения программы - это вызов функции abort(),

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

сохранения информации для отладчика (сброс оперативной памяти).

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

Более тонкие приемы обработки ошибок можно предложить, если

ориентироваться на особые ситуации (см.$$9), но предложенное решение

вполне приемлемо для игрушечного калькулятора в 200 строк.

3.1.5 Драйвер

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

инициализировать и запустить процесс. В нашем примере с этим

справится функция main():

int main()

{

// вставить предопределенные имена:

insert("pi")->value = 3.1415926535897932385;

insert("e")->value = 2.7182818284590452354;

while (cin) {

get_token();

if (curr_tok == END) break;

if (curr_tok == PRINT) continue;

cout << expr() << '\n';

}

return no_of_errors;

}

Принято, что функция main() возвращает нуль, если программа завершается

нормально, и ненулевое значение, если происходит иначе. Ненулевое

значение возвращается как число ошибок. Оказывается, вся инициализация

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

В цикле main читаются выражения и выдаются результаты. Это делает

одна строка:

cout << expr() << '\n';

Проверка cin при каждом проходе цикла гарантирует завершение программы,

даже если что-то случится с входным потоком, а проверка на лексему

END нужна для нормального завершения цикла, когда функция get_token()

обнаружит конец файла. Оператор break служит для выхода из

ближайшего объемлющего оператора switch или цикла (т.е. оператора for,

while или do). Проверка на лексему PRINT (т.е. на '\n' и ';') снимает

с функции expr() обязанность обрабатывать пустые выражения. Оператор

continue эквивалентен переходу на конец цикла, поэтому в нашем

случае фрагмент:

while (cin) {

// ...

if (curr_tok == PRINT) continue;

cout << expr() << "\n";

}

эквивалентен фрагменту:

while (cin) {

// ...

if (curr_tok == PRINT) goto end_of_loop;

cout << expr() << "\n";

end_of_loop: ;

}

Более подробно циклы описываются в $$R.6

3.1.6 Параметры командной строки

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

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

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

выражение. Если это выражение задать как параметр командной строки

запуска калькулятора, то можно сэкономить несколько нажатий клавиши.

Как уже было сказано, выполнение программы начинается вызовом main().

При этом вызове main() получает два параметра: число параметров (обычно

называемый argc) и массив строк параметров (обычно называемый argv).

Параметры - это символьные строки, поэтому argv имеет тип char*[argc+1].

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

передается в argv[0], поэтому argc всегда не меньше единицы. Например,

для командной строки

dc 150/1.1934

параметры имеют значения:

argc 2

argv[0] "dc"

argv[1] "150/1.1934"

argv[2] 0

Добраться до параметров командной строки просто; проблема в том, как

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

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

на символьную строку вместо файла ($$10.5.2). Например, можно определить

cin так, чтобы символы читались из строки, а не из стандартного

входного потока:

int main(int argc, char* argv[])

{

switch(argc) {

case 1: // считывать из стандартного входного потока

break;

case 2: // считывать из строки параметров

cin = *new istream(argv[1],strlen(argv[1]));

break;

default:

error("слишком много параметров");

return 1;

}

// дальше прежний вариант main

}

При этом istrstream - это функция istream, которая считывает

символы из строки, являющейся ее первым параметром. Чтобы использовать

istrstream нужно включить в программу файл <strstream.h>, а не

обычный <iostream.h>. В остальном же программа осталась без изменений,

кроме добавления параметров в функцию main() и использования их

в операторе switch. Можно легко изменить функцию main() так, чтобы она

могла принимать несколько параметров из командной строки. Однако

это не слишком нужно, тем более, что можно нескольких выражений

передать как один параметр:

dc "rate=1.1934;150/rate;19.75/rate;217/rate"

Кавычки необходимы потому, что символ ';' служит в системе UNIX

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

параметрах командной строки.

3.2 Сводка операций

Полное и подробное описание операций языка С++ дано в $$R.7. Советуем

прочитать этот раздел. Здесь же приводится краткая сводка операций и

несколько примеров. Каждая операция сопровождается одним или

несколькими характерными для нее именами и примером ее использования.

В этих примерах class_name обозначает имя класса, member - имя члена,

object - выражение, задающее объект класса, pointer - выражение, задающее

указатель, expr - просто выражение, а lvalue (адрес) - выражение,

обозначающее не являющийся константой объект. Обозначение (type) задает

имя типа в общем виде (с возможным добавлением *, () и т.д.).

Если оно указано без скобок, существуют ограничения.

Порядок применения унарных операций и операций присваивания

"справа налево", а всех остальных операций - "слева направо".

То есть, a=b=c означает a=(b=c), a+b+c означает (a+b)+c, и *p++ означает

*(p++), а не (*p)++.

____________________________________________________________

Операции С++

============================================================

:: Разрешение области видимости class_name :: member

:: Глобальное :: name

____________________________________________________________

. Выбор члена object . member

-> Выбор члена pointer -> member

[] Индексирование pointer [ expr ]

() Вызов функции expr ( expr_list )

() Структурное значение type ( expr_list )

sizeof Размер объекта sizeof expr

sizeof Размер типа sizeof ( type )

____________________________________________________________

++ Постфиксный инкремент lvalue ++

++ Префиксный инкремент ++ lvalue

-- Постфиксный декремент lvalue --

-- Префиксный декремент -- lvalue

~ Дополнение ~ expr

! Логическое НЕ ! expr

- Унарный минус - expr

+ Унарный плюс + expr

& Взятие адреса & lvalue

* Косвенность * expr

new Создание (размещение) new type

delete Уничтожение (освобождение) delete pointer

delete[] Уничтожение массива delete[] pointer

() Приведение(преобразование)типа ( type ) expr

____________________________________________________________

. * Выбор члена косвенный object . pointer-to-member

->* Выбор члена косвенный pointer -> pointer-to-member

____________________________________________________________

* Умножение expr * expr

/ Деление expr / expr

% Остаток от деления expr % expr

____________________________________________________________

+ Сложение (плюс) expr + expr

- Вычитание (минус) expr - expr

____________________________________________________________

Все операции таблицы, находящиеся между двумя ближайшими друг

к другу горизонтальными чертами,

имеют одинаковый приоритет. Приоритет операций уменьшается при

движении "сверху вниз". Например, a+b*c означает a+(b*c), так как *

имеет приоритет выше, чем +; а выражение a+b-c означает (a+b)-c,

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

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

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