Жанр: Учеба
Язык С++ с комментариями
...18284590452354;
while (cin) {
get_token();
if (curr_tok == END) break;
if (curr_tok == PRINT) continue;
cout "" expr() "" "\n";
}
return no_of_errors;
}
- стр 88 -
Принято обычно, что 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
}
Более подробно циклы описываются в #с.9.
3.1.6 Параметры командной строки
После того, как программа была написана и оттестирована, я
заметил, что часто набирать выражения на клавиатуре в стандартный
ввод надоедает, поскольку обычно использование программы состоит в
вычислении одного выражения. Если бы можно было представлять это
выражение как параметр командной строки, не приходилось бы так
много нажимать на клавиши.
Как уже говорилось, программа запускается вызовом main(). Когда
это происходит, main() получает два параметра: указывающий число
параметров, обычно называемый argc, и вектор параметров, обычно
называемый argv. Параметры - это символьные строки, поэтому argv
имеет тип char*[argc]. Имя программы (так, как оно стоит в
командной строке) передается в качестве argv[0], поэтому argc
всегда не меньше единицы. Например, в случае команды
dc 150/1.1934
- стр 89 -
параметры имеют значения:
argc 2
argv[0] "dc"
argv[1] "150/1.1934"
Научиться пользоваться параметрами командной строки несложно;
сложность состоит в том, как использовать их без
перепрограммирования. В данном случае это оказывается совсем
просто, поскольку поток ввода можно связать с символьной строкой, а
не с файлом (#8.5). Например, можно заставить cin читать символы из
стандартного ввода:
int main(int argc, char* argv[])
{
switch(argc) {
case 1: // читать из стандартного ввода
break;
case 2: // читать параметр строку
cin = *new istream(strlen(argv[1]),argv[1]);
break;
default:
error("слишком много параметров");
return 1;
}
// как раньше
}
Программа осталась без изменений, за исключением добавления в
main() параметров и использования этих параметров в операторе
switch. Можно было бы легко модифицировать main() так, чтобы она
получала несколько параметров командной строки, но это оказывается
ненужным, особенно потому, что несколько выражений можно передавать
как один параметр:
dc "rate=1.1934;150/rate;19.75/rate;217/rate"
Здесь кавычки необходимы, поскольку ; является разделителем
команд в системе UNIX.
3.2 Краткая сводка операций
Операции C++ подробно и систематически описываются в #с.7;
прочитайте, пожалуйста, этот раздел. Здесь же приводится краткая
сводка и некоторые примеры. После каждой операции приведено одно
или более ее общеупотребительных названий и пример ее
использования. В этих примерах имя_класса - это имя класса, член -
имя члена, объект - выражение, дающее в результате объект класса,
указатель - выражение, дающее в результате указатель, выр -
выражение, а lvalue - выражение, денотирующее неконстантный объект.
Тип может быть совершенно произвольным именем типа (со *, () и
т.п.) только когда он стоит в скобках, во всех остальных случаях
существуют ограничения.
- стр 90 -
Унарные операции и операции присваивания правоассоциативны, все
остальные левоассоциативны. Это значит, что a=b=c означает a=(b=c),
a+b+c означает (a+b)+c, и *p++ означает *(p++), а не (*p)++.
Сводка Операций (часть 1)
---------------------------------------------------------------
-----
:: разрешение области видимости имя_класса :: член
:: глобальное :: имя
---------------------------------------------------------------
-----
-" выбор члена указатель-"член
[] индексация указатель [ выр ]
() вызов функции выр (список_выр)
() построение значения тип (список_выр)
sizeof размер объекта sizeof выр
sizeof размер типа sizeof ( тип )
---------------------------------------------------------------
-----
++ приращение после lvalue++
++ приращение до ++lvalue
— уменьшение после lvalue--
— уменьшение до --lvalue
~ дополнение ~ выр
! не ! выр
- унарный минус - выр
+ унарный плюс + выр
& адрес объекта & lvalue
* разыменование * выр
new создание (размещение) new тип
delete уничтожение (освобождение) delete указатель
delete[] уничтожение вектора delete[ выр ]
указатель
() приведение (преобразование типа) ( тип ) выр
---------------------------------------------------------------
-----
* умножение выр * выр
/ деление выр / выр
% взятие по модулю (остаток) выр % выр
---------------------------------------------------------------
-----
+ сложение (плюс) выр + выр
- вычитание (минус) выр - выр
В каждой отчерченной части находятся операции с одинаковым
приоритетом. Операция имеет приоритет больше, чем операции из
частей, расположенных ниже. Например: a+b*c означает a+(b*c), так
как * имеет приоритет выше, чем +, а a+b-c означает (a+b)-c,
поскольку + и - имеют одинаковый приоритет (и поскольку +
левоассоциативен).
- стр 91 -
Сводка Операций (часть 2)
---------------------------------------------------------------
-----
"" сдвиг влево lvalue "" выр
"" сдвиг вправо lvalue "" выр
---------------------------------------------------------------
-----
" меньше выр " выр
"= меньше или равно выр "= выр
" больше выр " выр
"= больше или равно выр "= выр
---------------------------------------------------------------
-----
== равно выр == выр
!= не равно выр != выр
---------------------------------------------------------------
-----
& побитовое И выр & выр
---------------------------------------------------------------
-----
^ побитовое исключающее ИЛИ выр ^ выр
---------------------------------------------------------------
-----
| побитовое включающее ИЛИ выр | выр
---------------------------------------------------------------
-----
&& логическое И выр && выр
---------------------------------------------------------------
-----
|| логическое включающее ИЛИ выр || выр
---------------------------------------------------------------
-----
? : арифметический if выр ? выр : выр
---------------------------------------------------------------
-----
= простое присваивание lvalue = выр
*= умножить и присвоить lvalue = выр
/= разделить и присвоить lvalue /= выр
%= взять по модулю и присвоить lvalue %= выр
+= сложить и присвоить lvalue += выр
-= вычесть и присвоить lvalue -= выр
""= сдвинуть влево и присвоить lvalue ""= выр
""= сдвинуть вправо и присвоить lvalue ""= выр
&= И и присвоить lvalue &= выр
|= включающее ИЛИ и присвоить lvalue |= выр
^= исключающее ИЛИ и присвоить lvalue ^= выр
---------------------------------------------------------------
-----
, запятая (последование) выр , выр
- стр 92 -
3.2.1 Круглые скобки
Скобками синтаксис C++ злоупотребляет; количество способов их
использования приводит в замешательство: они применяются для
заключения в них параметров в вызовах функций, в них заключается
тип в преобразовании типа (приведении к типу), в именах типов для
обозначения функций, а также для разрешения конфликтов приоритетов.
К счастью, последнее требуется не слишком часто, потому что уровни
приоритета и правила ассоциативности определены таким образом,
чтобы выражения "работали ожидаемым образом" (то есть, отражали
наиболее привычный способ употребления). Например, значение
if (i"=0 || max
3.2.2 Порядок вычисления
Порядок вычисления подвыражений в выражении неопределен. Например
int i = 1;
v[i] = i++;
- стр 93 -
может вычисляться или как v[1]=1, или как v[2]=1. При отсутствии
ограничений на порядок вычисления выражения может генерироваться
более хороший код. Было бы замечательно, если бы компилятор
предупреждал о подобных неоднозначностях, но большинство
компиляторов этого не делают.
Относительно операций
, && ||
гарантируется, что их левый операнд вычисляется раньше, чем правый.
Например, b=(a=2,a=1) присвоит b 3. В #3.3.1 приводятся примеры
использования && и ||. Заметьте, что операция последования ,
(запятая) логически отличается от запятой, которая используется для
разделения параметров в вызове функции. Рассмотрим
f1(v[i],i++); // два параметра
f2( (v[i],i++) ) // один параметр
В вызове f1 два параметра, v[i] и i++, и порядок вычисления
выражений-параметров неопределен. Зависимость выражения-параметра
от порядка вычисления - это очень плохой стиль, а также
непереносимо. В вызове f2 один параметр, выражение с запятой,
которое эквивалентно i++.
С помощью скобок нельзя задать порядок вычисления. Например,
a*(b/c) может вычисляться и как (a*b)/c, поскольку * и / имеют
одинаковый приоритет. В тех случаях, когда важен порядок
вычисления, можно вводить дополнительную переменную, например,
(t=b/c,a*t).
3.2.2 Увеличение и уменьшение*
Операция ++ используется для явного выражения приращения вместо
его неявного выражения с помощью комбинации сложения и
присваивания. По определению ++lvalue означает lvalue+=1, что в
свою очередь означает lvalue=lvalue+1 при условии, что lvalue не
вызывает никаких побочных эффектов. Выражение, обозначающее
(денотирующее) объект, который должен быть увеличен, вычисляется
один раз (только). Аналогично, уменьшение выражается операцией --.
Операции ++ и — могут применяться и как префиксные, и как
постфиксные. Значением ++x является новое (то есть увеличенное)
значение x. Например, y=++x эквивалентно y=(x+=1). Значение x++,
напротив, есть старое значение x. Например, y=x++ эквивалентно
y=(t=x,x+=1,t), где t - переменная того же типа, что и x.
Операции приращения особенно полезны для увеличения и уменьшения
переменных в циклах. Например, оканчивающуюся нулем строку можно
копировать так:
inline void cpy(char* p, const char* q)
{
while (*p++ = *q++) ;
}
____________________
* Следовало бы переводить как "инкремент" и "декремент", однако
мы следовали терминологии, принятой в переводной литературе по C,
поскольку эти операции унаследованы от C. (прим. перев.)
- стр 94 -
Напомню, что увеличение и уменьшение указателей, так же как
сложение и вычитание указателей, осуществляется в терминах
элементов вектора, на которые указывает указатель; p++ приводит к
тому, что p указывает на следующий элемент. Для указателя p типа T*
по определению выполняется следующее:
long(p+1) == long(p)+sizeof(T);
3.2.4 Побитовые логические операции
Побитовые логические операции
& | ^ ~ "" ""
применяются к целым, то есть к объектам типа char, short, int, long
и их unsigned аналогам, результаты тоже целые.
Одно из стандартных применений побитовых логических операций -
реализация маленькиого множества (вектора битов). В этом случае
каждый бит беззнакового целого представляет один член множества, а
число членов ограничено числом битов. Бинарная операция &
интерпретируется как пересечение, | как объединение, а ^ как
разность. Для именования членов такого множества можно использовать
перечисление. Вот маленький пример, заимствованный из реализации
(не пользовательского интерфейса) :
enum state_value { _good=0, _eof=1, _fail=2, _bad=4};
// хорошо, конец файла, ошибка, плохо
Определение _good не является необходимым. Я просто хотел, чтобы
состояние, когда все в порядке, имело подходящее имя. Состояние
потока можно установить заново следующим образом:
cout.state = _good;
Например, так можно проверить, не был ли испорчен поток или
допущена операционная ошибка:
if (cout.state&(_bad|_fail)) // не good
Еще одни скобки необходимы, поскольку & имеет более высокий
приоритет, чем |.
Функция, достигающая конца ввода, может сообщать об этом так:
cin.state |= _eof;
Операция |= используется потому, что поток уже может быть испорчен
(то есть, state==_bad), поэтому
cin.state = _eof;
очистло бы этот признак. Различие двух потоков можно находить так:
state_value diff = cin.state^cout.state;
- стр 95 -
В случае типа stream_state (состояние потока) такая разность не
очень нужна, но для других похожих типов она оказывается самой
полезной. Например, при сравнении вектора бит, представляющего
множество прерываний, которые обрабатываются, с другим,
представляющим прерывания, ждущие обработки.
Следует заметить, что использование полей (#2.5.1) в
действительности является сокращенной записью сдвига и маскирования
для извлечения полей бит из слова. Это, конечно, можно сделать и с
помощью побитовых логических операций, Например, извлечь средние 16
бит из 32-битового int можно следующим образом:
unsigned short middle(int a) { return (a""8)&0xffff; }
Не путайте побитовые логические операции с логическими
операциями:
&& || !
Последние возвращают 0 или 1, и они главным образом используются
для записи проверки в операторах if, while или for (#3.3.1).
Например, !0 (не ноль) есть значение 1, тогда как ~0 (дополнение
нуля) есть набор битов все-единицы, который обычно является
значением -1.
3.2.5 Преобразование типа
Бывает необходимо явно преобразовать значение одного типа в
значение другого. Явное преобразование типа дает значение одного
типа для данного значения другого типа. Например:
float r = float(1);
перед присваиванием преобразует целое значение 1 к значению с
плавающей точкой 1.0. Результат преобразованиея типа не является
lvalue, поэтому ему нельзя присваивать (если только тип не является
ссылочным типом).
Есть два способа записи явного преобразования типа: традиционная
в C запись приведения к типу (double)a и функциональная запись
double(a). Функциональная запись не может применяться для типов,
которые не имеют простого имени. Например, чтобы преобразовать
значение к указательному типу надо или использовать запись
приведения
char* p = (char*)0777;
или определить новое имя типа:
typedef char* Pchar;
char* p = Pchar(0777);
По моему мнению, функциональная запись в нетривиальных случаях
предпочтительна. Рассмотрим два эквивалентных примера
- стр 96 -
Pname n2 = Pbase(n1-"tp)-"b_name; // функциональная запись
Pname n3 = ((Pbase)n2-"tp)-"b_name; // запись приведения к
типу
Поскольку операция -" имеет больший приоритет, чем приведение,
последнее выражение интерпретируется как
((Pbase)(n2-"tp))-"b_name
С помощью явного преобразования типа к указательным типам можно
сымитировать, что объект имеет совершенно произвольный тип.
Например:
any_type* p = (any_type*)&some_object;
позволит работать посредством p с некоторым объектом some_object
как с любым типом any_type.
Когда преобразование типа не необходимо, его следует избегать.
Программы, в которых используется много явных преобразований типов,
труднее понимать, чем те, в которых это не делается. Однако такие
программы легче понимать, чем программы, просто не использующие
типы для представления понятий более высокого уровня (например,
программу, которая оперирует регистром устройства с помощью сдвига
и маскирования, вместо того, чтобы определить подходящую struct и
оперировать ею; см. #2.5.2). Кроме того, правильность явного
преобразования типа часто критическим образом зависит от понимания
программистом того, каким образом объекты различных типов
обрабатываются в языке, и очень часто от подробностей реализации.
Например:
int i = 1;
char* pc = "asdf";
int* pi = &i;
i = (int)pc;
pc = (char*)i; // остерегайтесь: значение pc может измениться
// на некоторых машинах
// sizeof(int)
3.2.6 Свободная память
Именованный объект является либо статическим, либо автоматическим
(см. #2.1.3). Статический объект размещается во время запуска
программы и существует в течение всего выполнения программы.
Автоматический объект размещается каждый раз при входе в его блок и
существует только до тех пор, пока из этого блока не вышли. Однако
часто бывает полезно создать новый объект, существующий до тех пор,
пока он не станет больше не нужен. В частности, часто полезно
создать объект, который можно использовать после возврата из
функции, где он создается. Такие объекты создает операция new, а
впоследствие уничтожать их можно операцией delete. Про объекты,
выделенные с помощью операции new, говорят, что они в свободной
памяти. Такими объектами обычно являются вершины деревьев или
элементы связанных списков, являющиеся частью большей структуры
данных, размер которой не может быть известен на стадии компиляции.
Рассмотрим, как можно было бы написать компилятор в духе
написанного настольного калькулятора. Функции синтаксического
анализа могут строить древовидное представление выражений, которое
будет использоваться при генерации кода. Например:
struct enode {
token_value oper;
enode* left;
enode* right;
};
enode* expr()
{
enode* left = term();
for(;;)
switch(curr_tok) {
case PLUS:
case MINUS:
get_token();
enode* n = new enode;
n-"oper = curr_tok;
n-"left = left;
n-"right = term();
left = n;
break;
default:
return left;
}
}
Получающееся дерево генератор кода может использовать например так:
- стр 98 -
void generate(enode* n)
{
switch (n-"oper) {
case PLUS:
// делает нечто соответствуюшее
delete n;
}
}
Объект, созданный с помощью new, существует, пока он не будет
явно уничтожен delete, после чего пространство, которое он
занимал, опять может использоваться new. Никакого "сборщика
мусора", который ищет объекты, на которые нет ссылок, и
предоставляет их в распоряжение new, нет. Операция delete может
применяться только к указателю, который был возвращен операцей new,
или к нулю. Применение delete к нулю не вызывает никаких действий.
С помощью new можно также создавать вектора объектов. Например:
char* save_string(char* p)
{
char* s = new char[strlen(p)+1];
strcpy(s,p);
return s;
}
Следует заметить, что чтобы освободить пространство, выделенное
new, delete должна иметь возможность определить размер выделенного
объекта. Например:
int main(int argc, char* argv[])
{
if (argc " 2) exit(1);
char* p = save_string(argv[1]);
delete p;
}
Это приводит к тому, что объект, выделенный стандартной реализацией
new, будет занимать больше места, чем статический объект (обыно,
больше на одно слово).
Можно также явно указывать размер вектора в операции уничтожения
delete. Например:
int main(int argc, char* argv[])
{
if (argc " 2) exit(1);
int size = strlen(argv[1])+1;
char* p = save_string(argv[1]);
delete[size] p;
}
Заданный пользователем размер вектора игнорируется за исключением
некоторых типов, определяемых пользователем (#5.5.5).
Операции свободной памяти реализуются функциями (#с.7.2.3):
void operator new(long);
void operator delete(void*);
- стр 99 -
Стандартная реализация new не инициализирует возвращаемый объект.
Что происходит, когда new не находит памяти для выделения?
Поскольку даже виртуальная память конечна, это иногда должно
происходить. Запрос вроде
char* p = new char[100000000];
как правило, приводит к каким-то неприятностям. Когда у new ничего
не получается, она вызывает функцию, указываемую указаетелем
_new_handler (указатели на функции обсуждаются в #4.6.9). Вы можете
задать указатель явно или использовать функцию set_new_handler().
Например:
#include
void out_of_store()
{
cerr "" "операция new не прошла: за пределами памяти\n";
exit(1);
}
typedef void (*PF)(); // тип указатель на функцию
extern PF set_new_handler(PF);
main()
{
set_new_handler(out_of_store);
char* p = new char[100000000];
cout "" "сделано, p = " "" long(p) "" "\n";
}
как правило, не будет писать "сделано", а будет вместо этого
выдавать
операция new не прошла: за пределами памяти
_new_handler может делать и кое-что поумнее, чем просто завершать
выполнение программы. Если вы знаете, как работают new и delete,
например, потому, что вы задали свои собственные operator new() и
operator delete(), программа обработки может попытаться найти
некоторое количество памяти, которое возвратит new. Другими
словами, пользователь может сделать сборщик мусора, сделав, таким
образом, использование delete необязательным. Но это, конечно, всетаки
задача не для начинающего.
По историческим причинам new просто возвращает указатель 0, если
она не может найти достаточное количество памяти и не был задан
никакой _new_handler. Например
include
main()
{
char* p = new char[100000000];
cout "" "сделано, p = " "" long(p) "" "\n";
}
- стр 100 -
выдаст
сделано, p = 0
Вам сделали предупреждение! Заметьте, что тот, кто задает
_new_handler, берет на себя заботу по проверке истощения памяти при
каждом использовании new в програме (за исключением случая, когда
пользователь задал отдельные подпрограммы для размещения объектов
заданных типов, определяемых пользователем; см. #5.5.6).
3.3 Сводка операторов
Операторы C++ систематически и полностью изложены в #с.9,
прочитайте, пожалуйста, этот раздел. А здесь приводится краткая
сводка и некоторые примеры.
Синтаксис оператора
---------------------------------------------------------------
-----
оператор:
описание
{список_операторов opt}
выражение opt
if ( выражение ) опреатор
if ( выражение ) оператор else оператор
switch ( выражение ) оператор
while ( выражение ) оператор
do оператор while (выражение)
for ( оператор выражение opt ; выражение opt ) оператор
case константное_выражение : оператор
default : оператор
break ;
continue ;
return выражение opt ;
goto идентификатор ;
идентификатор : оператор
список_операторов:
оператор
оператор список_операторов
Заметьте, что описание является оператором, и что нет операторов
присваивания и вызова процедуры. Присваивание и вызов функции
обрабатываются как выражения.
- стр 101 -
3.3.1 Проверки
Проверка значения может осуществляться или оператором if, или
оператором switch:
if ( выражение ) оператор
if ( выражение ) оператор else оператор
switch ( выражение ) оператор
В C++ нет отдельного булевского типа. Операции сравнения
== != " "= " "=
возвращают целое 1, если сравнение истинно, иначе возвращают 0. Не
так уж непривычно видеть, что ИСТИНА определена как 1, а ЛОЖЬ
определена как 0.
В операторе if первый (или единственный) оператор выполняется в
том случае, если выражение ненулевое, иначе выполняется второй
оператор (если он задан). Отсюда следует, что в качестве условия
может использоваться любое целое выражение. В частности, если a
целое, то
if (a) // ...
эквивалентно
if (a != 0) // ...
Логические операции
&&
...Закладка в соц.сетях
