Geum.ru

* законченный учебник и руководство по языку

Вид материалаЗакон
Подобный материал:
1   2   3   4   5   6   7   8   9   ...   34
. В остальном же программа осталась без изменений,

кроме добавления параметров в функцию 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,

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

применяются "слева направо".


Э

____________________________________________________________

Операции С++ (продолжение)

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

<< Сдвиг влево expr << expr

>> Сдвиг вправо expr >> expr

____________________________________________________________

< Меньше expr < expr

<= Меньше или равно expr <= expr

> Больше expr > expr

>= Больше или равно expr >= expr

____________________________________________________________

== Равно expr == expr

!= Не равно expr != expr

____________________________________________________________

& Поразрядное И expr & expr

____________________________________________________________

^ Поразрядное исключающее ИЛИ expr ^ expr

____________________________________________________________

| Поразрядное включающее ИЛИ expr | expr

____________________________________________________________

&& Логическое И expr && expr

____________________________________________________________

|| Логическое ИЛИ expr || expr

____________________________________________________________

? : Операция условия expr? expr : expr

____________________________________________________________

= Простое присваивание lvalue = expr

*= Присваивание с умножением lvalue *= expr

/= Присваивание с делением lvalue /= expr

%= Присваивание с взятием lvalue %= expr

остатка от деления

+= Присваивание со сложением lvalue += expr

-= Присваивание с вычитанием lvalue -= expr

<<= Присваивание со сдвигом влево lvalue <<= expr

>>= Присваивание со сдвигом вправо lvalue >>= expr

&= Присваивание с поразрядным И lvalue &= expr

|= Присваивание с поразрядным lvalue |= expr

включающим ИЛИ

^= Присваивание с поразрядным lvalue ^= expr

исключающим ИЛИ

____________________________________________________________

Запятая (последовательность) expr , expr

____________________________________________________________


3.2.1 Скобки


Синтаксис языка С++ перегружен скобками, и разнообразие их применений

способно сбить с толку. Они выделяют фактические параметры при

вызове функций, имена типов, задающих функции, а также служат для

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

К счастью, последнее встречается не слишком часто, поскольку приоритеты

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

"естественным образом" (т.е. наиболее распространенным образом).

Например, выражение


if (i<=0 || max

означает следующее: "Если i меньше или равно нулю, или если max меньше i".

То есть, оно эквивалентно


if ( (i<=0) || (max

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


if (i <= (0||max) < i) // ...


Тем не менее, если программист не уверен в указанных правилах,

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

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


if ( (i<=0) || (max

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

забывать, что сложные выражения являются источником ошибок. Поэтому,

если у вас появится ощущение, что в этом выражении нужны скобки,

лучше разбейте его на части и введите дополнительную переменную.

Бывают случаи, когда приоритеты операций не приводят к "естественному"

порядку вычислений. Например, в выражении


if (i&mask == 0) // ловушка! & применяется после ==


не происходит маскирование i (i&mask), а затем проверка результата

на 0. Поскольку у == приоритет выше, чем у &, это выражение эквивалентно

i&(mask==0). В этом случае скобки играют важную роль:


if ((i&mask) == 0) // ...


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

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


if (0 <= a <= 99) // ...


Оно допустимо, но интерпретируется как (0<=a)<=99, и результат первого

сравнения равен или 0, или 1, но не значению a (если, конечно,

a не есть 1). Проверить, попадает ли a в диапазон 0...99, можно так:


if (0<=a && a<=99) // ...


Среди новичков распространена ошибка, когда в условии вместо ==

(равно) используют = (присвоить):


if (a = 7) // ошибка: присваивание константы в условии

// ...


Она вполне объяснима, поскольку в большинстве языков "=" означает "равно".

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


3.2.2 Порядок вычислений


Порядок вычисления подвыражений, входящих в выражение, не всегда

определен. Например:


int i = 1;

v[i] = i++;


Здесь выражение может вычисляться или как v[1]=1, или как v[2]=1.

Если нет ограничений на порядок вычисления подвыражений, то транслятор

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

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

большинство из них не делает этого.

Для операций


&& || ,


гарантируется, что их левый операнд вычисляется раньше правого операнда.

Например, в выражении b=(a=2,a+1) b присвоится значение 3. Пример

операции || был дан в $$3.2.1, а пример операции && есть в $$3.3.1.

Отметим, что операция запятая отличается по смыслу от той запятой, которая

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

выражения:


f1(v[i],i++); // два параметра

f2( (v[i],i++) ) // один параметр


Вызов функции f1 происходит с двумя параметрами: v[i] и i++, но

порядок вычисления выражений параметров неопределен. Зависимость

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

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

становится непереносимой.

Вызов f2 происходит с одним параметром, являющимся выражением,

содержащим операцию запятая: (v[i], i++). Оно эквивалентно i++.

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

a*(b/c) может вычисляться как (a*b)/c (если только пользователь

видит в этом какое-то различие). Заметим, что для значений с плавающей

точкой результаты вычисления выражений a*(b/c) и (a*b)/ могут

различаться весьма значительно.


3.2.3 Инкремент и декремент


Операция ++ явно задает инкремент в отличие от неявного его задания

с помощью сложения и присваивания. По определению ++lvalue означает

lvalue+=1, что, в свою очередь означает lvalue=lvalue+1 при условии,

что содержимое lvalue не вызывает побочных эффектов. Выражение,

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

обозначается операция декремента (--). Операции ++ и -- могут

использоваться как префиксные и постфиксные операции. Значением ++x

является новое (т. е. увеличенное на 1) значение x. Например, y=++x

эквивалентно y=(x+=1). Напротив, значение x++ равно прежнему значению x.

Например, y=x++ эквивалентно y=(t=x,x+=1,t), где t - переменная того

же типа, что и x.

Напомним, что операции инкремента и декремента указателя

эквивалентны сложению 1 с указателем или вычитанию 1 из указателя, причем

вычисление происходит в элементах массива, на который настроен

указатель. Так, результатом p++ будет указатель на следующий элемент.

Для указателя p типа T* следующее соотношение верно по определению:


long(p+1) == long(p) + sizeof(T);


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

изменения переменных в цикле. Например, копирование строки,

оканчивающейся нулевым символом, задается следующим образом:


inline void cpy(char* p, const char* q)

{

while (*p++ = *q++) ;

}


Язык С++ (подобно С) имеет как сторонников, так и противников именно

из-за такого сжатого, использующего сложные выражения стиля

программирования. Оператор


while (*p++ = *q++) ;


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

Имеет смысл повнимательнее посмотреть на такие конструкции, поскольку

для C и C++ они не является редкостью.

Сначала рассмотрим более традиционный способ копирования массива

символов:


int length = strlen(q)

for (int i = 0; i<=length; i++) p[i] = q[i];


Это неэффективное решение: строка оканчивается нулем; единственный

способ найти ее длину - это прочитать ее всю до нулевого символа;

в результате строка читается и для установления ее длины, и для

копирования, то есть дважды. Поэтому попробуем такой вариант:


for (int i = 0; q[i] !=0 ; i++) p[i] = q[i];

p[i] = 0; // запись нулевого символа


Поскольку p и q - указатели, можно обойтись без переменной i,

используемой для индексации:


while (*q !=0) {

*p = *q;

p++; // указатель на следующий символ

q++; // указатель на следующий символ

}

*p = 0; // запись нулевого символа


Поскольку операция постфиксного инкремента позволяет сначала использовать

значение, а затем уже увеличить его, можно переписать цикл так:


while (*q != 0) {

*p++ = *q++;

}

*p = 0; // запись нулевого символа


Отметим, что результат выражения *p++ = *q++ равен *q. Следовательно,

можно переписать наш пример и так:


while ((*p++ = *q++) != 0) { }


В этом варианте учитывается, что *q равно нулю только тогда, когда

*q уже скопировано в *p, поэтому можно исключить завершающее

присваивание нулевого символа. Наконец, можно еще более сократить

запись этого примера, если учесть, что пустой блок не нужен, а

операция "!= 0" избыточна, т.к. результат условного выражения и так

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

первоначальному варианту, который вызывал недоумение:


while (*p++ = *q++) ;


Неужели этот вариант труднее понять, чем приведенные выше? Только

неопытным программистам на С++ или С! Будет ли последний вариант

наиболее эффективным по затратам времени и памяти? Если не считать

первого варианта с функцией strlen(), то это неочевидно. Какой из

вариантов окажется эффективнее, определяется как спецификой системы

команд, так и возможностями транслятора. Наиболее эффективный алгоритм

копирования для вашей машины можно найти в стандартной функции копирования

строк из файла :


int strcpy(char*, const char*);


3.2.4 Поразрядные логические операции


Поразрядные логические операции


& | ^ ~ >> <<


применяются к целым, то есть к объектам типа char, short, int, long и

к их беззнаковым аналогам. Результат операции также будет целым.

Чаще всего поразрядные логические операции используются для

работы с небольшим по величине множеством данных (массивом разрядов).

В этом случае каждый разряд беззнакового целого представляет один

элемент множества, и число элементов определяется количеством разрядов.

Бинарная операция & интерпретируется как пересечение множеств,

операция | как объединение, а операция ^ как разность множеств.

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

Ниже приведен пример, заимствованный из :


class ios {

public:

enum io_state {

goodbit=0, eofbit=1, failbit=2, badbit=4

};

// ...

};


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


cout.state = ios::goodbit;


Уточнение именем ios необходимо, потому что определение io_state находится

в классе ios, а также чтобы не возникло коллизий, если пользователь заведет свои

имена наподобие goodbit.

Проверку на корректность потока и успешное окончание операции можно

задать так:


if (cout.state&(ios::badbit|ios::failbit)) // ошибка в потоке


Еще одни скобки необходимы потому, что операция & имеет более высокий

приоритет, чем операция "|".

Функция, обнаружившая конец входного потока, может сообщать об этом так:


cin.state |= ios::eofbit;


Операция |= используется потому, что в потоке уже могла быть ошибка

(т.е. state==ios::badbit), и присваивание


cin.state =ios::eofbit;


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

потоков можно следующим способом:


ios::io_state diff = cin.state^cout.state;


Для таких типов, как io_state, нахождение различий не слишком полезная

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

полезной. Например, полезно сравнение двух разрядных массива, один из

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

а другой - набор прерываний, ожидающих обработки.

Отметим, что использование полей ($$R.9.6) может служить удобным

и более лаконичным способом работы с частями слова, чем сдвиги и

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

логических операций. Например, можно выделить средние 16 разрядов

из средины 32-разрядного целого:


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.0f. Результат преобразования типа не является

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

ссылкой).

Существуют два вида записи явного преобразования типа:

традиционная запись, как операция приведения в С, например, (double)a

и функциональная запись, например, double(a). Функциональную запись

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

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

использовать приведение


char* p = (char*)0777;


или определить новое имя типа:


typedef char* Pchar;

char* p = Pchar(0777);


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

предпочтительнее. Рассмотрим два эквивалентных примера:


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;


позволит обращаться к некоторому объекту (some_object) через указатель

p как к объекту произвольного типа (any_type). Тем не менее, если

some_object в действительности имеет тип не any_type, могут получиться

странные и нежелательные результаты.

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

избегать. Программы, в которых есть такие преобразования, обычно

труднее понимать, чем программы, их не имеющие. В то же время

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

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

не вводят типов для представления понятий более высокого уровня.

Так, например, поступают программы, управляющие регистром устройства с

помощью сдвига и маскирования целых, вместо того, чтобы определить

подходящую структуру (struct) и работать непосредственно с ней

(см. $$2.6.1). Корректность явного преобразования типа часто

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

работает с объектами различных типов, и какова специфика данной реализации

языка. Приведем пример:


int i = 1;

char* pc = "asdf";

int* pi = &i;

i = (int)pc;

pc = (char*)i; // осторожно: значение pc может измениться.

// На некоторых машинах sizeof(int)

// меньше, чем sizeof(char*)

pi = (int*)pc;

pc = (char*)pi; // осторожно: pc может измениться

// На некоторых машинах char* имеет не такое

// представление, как int*


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

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

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

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

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

типа) указателю типа void*, а void* может быть явно преобразован

обратно в указатель произвольного типа.

В языке С++ явные преобразования типа оказывается излишними во многих

случаях, когда в С (и других языках) они требуются. Во многих

программах можно вообще обойтись без явных преобразований типа, а во

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


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;

}

}


Генератор кода может использовать дерево выражений, например так:


void generate(enode* n)

{

switch (n->oper) {

case PLUS:

// соответствующая генерация

delete n;

}

}


Объект, созданный с помощью операции new, существует, до тех пор,

пока он не будет явно уничтожен операцией delete. После этого

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

никакого "сборщика мусора", ищущего объекты, на которые никто

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

повторного использования. Операндом delete может быть

только указатель, который возвращает операция new, или нуль.

Применение delete к нулю не приводит ни к каким действиям.

Операция new может также создавать массивы объектов, например:


char* save_string(const 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(arg[1]);

delete[] p;

}


Чтобы добиться этого, приходится под объект, размещаемый стандартной

операцией new, отводить немного больше памяти, чем под статический

(обычно, больше на одно слово). Простой оператор delete уничтожает

отдельные объекты, а операция delete[] используется для уничтожения

массивов.

Операции со свободной памятью реализуются функциями ($$R.5.3.3-4):


void* operator new(size_t);

void operator delete(void*);


Здесь size_t - беззнаковый целочисленный тип, определенный в .

Стандартная реализация функции operator new() не инициализирует

предоставляемую память.

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

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

такое время от времени происходит. Так, запрос вида:


char* p = new char [100000000];


обычно не проходит нормально. Когда операция new не может выполнить

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

при обращении к функции set_new_handler() из . Например,

в следующей программе:


#include