Введение в язык Си++
         

Операции отношения


Операции отношения (сравнения) группируют слева направо, но этот факт не очень-то полезен: a выражение_отношения:

выражение выражение выражение = выражение


Операции (больше чем), = все дают 0, если заданное соотношение ложно, и 1, если оно истинно. Тип результата int. Выполняются обычные арифметические преобразования. Могут сравниваться два указателя; результат зависит от относительного положения объектов, на которые указывают указатели, в адресном пространстве. Сравнение указателей переносимо только если указатели указывают на объекты одного массива.



Операции Преобразования


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

[1] Не может быть неявного преобразования из определенного пользователем типа в основной тип (поскольку основные типы не являются классами);

[2] Невозможно задать преобразование из нового типа в старый, не изменяя описание старого; и

[3] Невозможно иметь конструктор с одним параметром, не имея при этом преобразования.

Последнее не является серьезной проблемой, а с первыми двумя можно справиться, определив для исходного типа операцию преобразования. Функция член X::operator T(), где T - имя типа, определяет преобразование из X в T. Например, можно определить тип tiny (крошечный), который может иметь значение только в диапазоне 0...63, но все равно может свободно сочетаться в целыми в арифметических операциях:

class tiny { char v; int assign(int i) { return v = (i~63) ? (error("ошибка диапазона"),0) : i; } public: tiny(int i) { assign(i); } tiny(tiny i) { v = t.v; } int operator=(tiny i) { return v = t.v; } int operator=(int i) { return assign(i); } operator int() { return v; } }

Диапазон значения проверяется всегда, когда tiny инициализируется int, и всегда, когда ему присваивается int. Одно tiny может присваиваться другому без проверки диапазона. Чтобы разрешить выполнять над переменными tiny обычные целые операции, определяется tiny::operator int(), неявное преобразование из int в tiny. Всегда, когда в том месте, где требуется int, появляется tiny, используется соответствующее ему int. Например:

void main() { tiny c1 = 2; tiny c2 = 62; tiny c3 = c2 - c1; // c3 = 60 tiny c4 = c3; // нет проверки диапазона (необязательна) int i = c1 + c2; // i = 64 c1 = c2 + 2 * c1; // ошибка диапазона: c1 = 0 (а не 66) c2 = c1 -i; // ошибка диапазона: c2 = 0 c3 = c2; // нет проверки диапазона (необязательна) }

Тип вектор из tiny может оказаться более полезным, поскольку он экономит пространство. Чтобы сделать этот тип более удобным в обращении, можно использовать операцию индексирования.

Другое применение определяемых операций преобразования - это типы, которые предоставляют нестандартные представления чисел (арифметика по основанию 100, арифметика с фиксированной точкой, двоично-десятичное представление и т.п.). При этом обычно переопределяются такие операции, как + и *.

Функции преобразования оказываются особенно полезными для работы со структурами данных, когда чтение (реализованное посредством операции преобразования) тривиально, в то время как присваивание и инициализация заметно более сложны.

Типы istream и ostream опираются на функцию преобразования, чтобы сделать возможными такие операторы, как while (cinx) coutx выше возвращает istream. Это значение неявно преобразуется к значению, которое указывает состояние cin, а уже это значение может проверяться оператором while (см. ). Однако определять преобразование из оного типа в другой так, что при этом теряется информация, обычно не стоит.





Операции присваивания


Есть много операций присваивания, все группируют слева направо. Все в качестве левого операнда требуют lvalue, и тип выражения присваивания тот же, что и у его левого операнда. Это lvalue не может ссылаться на константу (имя массива, имя функции или const). Значением является значение, хранящееся в левом операнде просле выполнения присваивания.

выражение_присваивания:

выражение операция_присваивания выражение

операция_присваивания: одна из

= += -= *= /= %= =

В простом присваивании с = значение выражения замещает собой значение объекта, на который ссылается операнд в левой части. Если оба операнда имеют арифметический тип, то при подготовке к присваиванию правый операнд преобразуется к типу левого. Если аргумент в левой части имеет указательный тип, аргумент в правой части должен быть того же типа или типа, кторый может быть преобразован к нему, см. #6.7. Оба операнда могут быть объектами одного класса. Могут присваиваться объекты некоторых производных классов; см.

Присваивание объекту типа "указатель на ..." выполнит присваивание объекту, денотируемому ссылкой.

Выполнение выражения вида E1 op= E2 можно представить себе как эквивалентное E1 = E1 op (E2); но E1 вычисляется только один раз. В += и -= левый операнд может быть указателем, и в этом случае (интегральный) правый операнд преобразуется так, как объяснялось в ; все правые операнды и не являющиеся указателями левые должны иметь арифметический тип.



Операции равенства


выражение_равенства:

выражение == выражение выражение != выражение


Операции == и != в точности аналогичны операциям сравнения за исключением их низкого приоритета. (Так, a



Операции сдвига


Операции сдвига группируют слева направо. Обе выполняют одно обычное арифметическое преобразование над своими операндами, каждый из которых должен быть целым. В этом случае правый операнд преобразуется к типу int; тип результата совпадает с типом левого операнда. Результат не определен, если правый операнд отрицателен или больше или равен длине объекта в битах.

сдвиговое_выражение:

выражение выражение

Значением Е1 Е2 является Е1 , сдвинутое вправо на Е2 битовых позиций. Гарантируется, что сдвиг вправо является логическим (заполнение нулями), если Е1 является unsigned; в противном случае он может быть арифметическим (заполнение копией знакового бита).



Операция логическое И


логическое_И_выражение:

выражение выражение


Операция группирует слева направо. Она возвращает 1, если оба операнда ненулевые, и 0 в противном случае. В противоположность операции операция гарантирует вычисление слева направо; более того, второй операнд не вычисляется, если первый операнд есть 0.

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



Операция логическое ИЛИ


логическое_ИЛИ_выражение:

выражение выражение


Операция группирует слева направо. Она возвращает 1, если хотя бы один из ее операндов ненулевой, и 0 в противном случае. В противоположность операции | операция гарантирует вычисление слева направо; более того, второй операнд не вычисляется, если первый операнд не есть 0.

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



Операция побитовое И


И-выражение:

выражение выражение


Операция ассоциативна, и выражения, содержащие , могут реорганизовываться. Выполняются обычные арифметические преобразования; результатом является побитовая функция И операндов. Операция применяется только к целым операндам.



Операция побитовое исключающее ИЛИ


исключающее_ИЛИ_выражение:

выражение ^ выражение


Операция ^ ассоциативна, и выражения, содержащие ^, могут реорганизовываться. Выполняются обычные арифметические преобразования; результатом является побитовая функция исключающее ИЛИ операндов. Операция применяется только к целым операндам.



Операция побитовое включающее ИЛИ


включающее_ИЛИ_выражение:

выражение | выражение


Операция | ассоциативна, и выражения, содержащие |, могут реорганизовываться. Выполняются обычные арифметические преобразования; результатом является побитовая функция включающее ИЛИ операндов. Операция применяется только к целым операндам.



Операция запятая


запятая_выражение:

выражение , выражение

Пара выражений, разделенных запятой, вычисляется слева направо, значение левого выражения теряется. Тип и значение результата являются типом и значением правого операнда. Эта операция группирует слева направо. В контексте, где запятая имеет специальное значение, как например в списке фактических параметров функции () и в списке инициализаторов (#8.6), операция запятая, как она описана в этом разделе, может появляться только в скобках; например,

f (a,(t=3,t+2),c)

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



Оператор asm


Оператор asm имеет вид

asm ( строка) ;

Смысл оператора asm не определен. Обычно он используется для передачи информации через компилятор ассемблеру.



Оператор break


Оператор

break ;

прекращает выполнение ближайшего охватывающего while, do, for или switch оператора; управление передается на оператор, следующий за законченным.



Оператор continue


Оператор

continue ;

вызывает передачу управления на управляющую продолжением цикла часть наименьшего охватывающего оператора while, do или for; то есть на конец петли цикла. Точнее, в каждом из операторов

while (...)

 do

 for (...)
{

 {

 {
...

 ...

 ...
contin:;

 contin:;

 contin:;
}

 }

 }
while (...);

continue эквивалентно goto contin. (За contin: следует пустой оператор, #9.13.)



Оператор delete


Оператор delete имеет вид

delete выражение ;

Результатом выражения должен быть указатель. Объект, на который он указывает, уничтожается. Это значит, что после оператора уничтожения delete нельзя гарантировать, что объект имеет определенное значение; см. #17. Эффект от применения delete к указателю, не полученному из операции new (#7.1), не определен. Однако, уничтожение указателя с нулевым значением безопасно.



Оператор do


Оператор do имеет вид

do оператор while (выражение);

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



Оператор for


Рассмотрим копирование десяти элементов одного вектора в другой:

for (int i=0; i

Это эквивалентно

int i = 0; while (i

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

for (i=0; i

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


Оператор for имеет вид

for ( выражение_1 opt ; выражение_2 opt ; выражение_3 opt ) оператор

Этот оператор эквивалентен следующему:

выражение_1; while (выражение_2) { оператор выражение_3; }

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

Каждое или все выражения могут быть опущены. Отсутствие выражения_2 делает подразумеваемое while-предложение эквивалентным while(1); остальные опущенные выражения просто пропускаются в описанном выше расширении.



Оператор goto


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

goto идентификатор ;

Идентификатор должен быть меткой (#9.12), расположенной в текущей функции.



Оператор return


Возврат из функции в вызывающую программу осуществляется с помощью оператора return, имеющего один из двух видов:

return ; return выражение ;

Первый может использоваться только в функциях, не возвращающих значения, т.е. в функциях с типом возвращаемого значения void. Вторая форма может использоваться только в функциях, не возвращающих значение; вызывающей функцию программе возвращается значение выражения. Если необходимо, то выражение преобразуется, как это делается при присваивании, к типу функции, в которой оно возникло. Обход конца функции эквивалентен возврату return без возвращаемого значения.



Оператор switch


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

switch ( выражение ) оператор

Выражение должно быть целого типа или типа указателя. Любой оператор внутри оператора может быть помечен одним или более префиксом case следующим образом:

case константное_выражение :

где константное выражение должно иметь тот же тип что и выражение- переключатель; производятся обычные арифметические преобразования. В одном операторе switch никакие две константы, помеченные case, не могут иметь одинаковое значение. Константные выражения точно определяются в #15.

Может также быть не более чем один префикс оператора вида

default :

Когда выполнен оператор switch, проведено вычисление его выражения и сравнение его с каждой case константой. Если одна из констант равна значению выражения, то управление передается на выражение, следующее за подошедшим префиксом case. Если никакая case константа не соответствует выражению, и есть префикс default, то управление передается на выражение, которому он предшествует. Если нет соответствующих вариантов case и default отсутствует, то никакой из операторов в операторе switch не выполняется.

Префиксы case и default сами по себе не изменяют поток управления, который после задержки идет дальше, перескакивая через эти префиксы. Для выхода из switch см. break, #9.8.

Обычно зависящий от switch оператор является составным. В голове этого оператора могут стоять описания, но инициализации автоматических и регистровых переменных являются безрезультатными.



Оператор выражение


Большинство операторов является операторами выражение, которые имеют вид выражение ;

Обычно операторы выражение являются присваиваниями и вызовами функций.



Оператор while


Рассмотрим копирование строки, когда заданы указатель p на ее первый символ и указатель q на целевую строку. По соглашению строка оканчивается символом с целым значением 0.

while (p != 0) { *q = *p; // скопировать символ q = q+1; p = p+1; } *q = 0; // завершающий символ 0 скопирован не был

Следующее после while условие должно быть заключено в круглые скобки. Условие вычисляется, и если его значение не ноль, выполняется непосредственно следующий за ним оператор. Это повторяется до тех пор, пока вычисление условия не даст ноль.

Этот пример слишком пространен. Можно использовать операцию ++ для непосредственного указания увеличения, и проверка упростится:

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

где конструкция *p++ означает: "взять символ, на который указывает p, затем увеличить p."

Пример можно еще упростить, так как указатель p разыменовывается дважды за каждый цикл. Копирование символа можно делать тогда же, когда производится проверка условия:

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

Здесь берется символ, на который указывает p, p увеличивается, этот символ копируется туда, куда указывает q, и q увеличивается. Если символ ненулевой, цикл повторяется. Поскольку вся работа выполняется в условии, не требуется ни одного оператора. Чтобы указать на это, используется пустой оператор. C++ (как и C) одновременно любят и ненавидят за возможность такого чрезвычайно краткого ориентированного на выразительность программирования *4.


Оператор while имеет вид

while ( выражение ) оператор

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



Операторы


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


составной_оператор: { список_описаний opt список_операторов opt } список_описаний: описание описание список_описаний список_операторов: оператор оператор список_операторов оператор: выражение ; if ( выражение ) оператор if ( выражение ) оператор else оператор while ( выражение ) оператор do оператор while ( выражение ) ; for ( выражение opt ; выражение opt ; выражение opt ) оператор switch ( выражение ) оператор case константное выражение : оператор default : оператор break; continue; return выражение opt ; goto идентификатор ; идентификатор : оператор delete выражение ; asm ( строка ) ; ;



Операторы if


Программа в следующем примере осуществляет преобразование дюймов в сантиметры и сантиметров в дюймы; предполагается, что вы укажете единицы измерения вводимых данных, добавляя i для дюймов и c для сантиметров:

#include

main() { const float fac = 2.54; float x, in, cm; char ch = 0;

cout x ch;

if (ch == 'i') { // inch - дюймы in = x; cm = x*fac; } else if (ch == 'c') // cm - сантиметры in = x/fac; cm = x; } else in = cm = 0;

cout

Заметьте, что условие в операторе if должно быть заключено в круглые скобки.



Операторы switch


Оператор switch производит сопоставление значения с множеством констант. Проверки в предыдущем примере можно записать так:

switch (ch) { case 'i': in = x; cm = x*fac; break; case 'c': in = x/fac; cm = x; break; default: in = cm = 0; break; }

Операторы break применяются для выхода из оператора switch. Константы в вариантах case должны быть различными, и если проверяемое значение не совпадает ни с одной из констант, выбирается вариант default. Программисту не обязательно предусматривать default.



Операторы Выражения


Самый обычный вид оператора - оператор выражение. Он состоит из выражения, за которым следует точка с запятой. Например:

a = b*3+c; cout



Описание Asm


Описание Asm имеет вид

asm (строка);

Смысл описания asm не определен. Обычно оно используется для передачи информации ассемблеру через компилятор.

*1 В английском "garbage", означающее затертое место [памяти], т.е. если переменная целая, то 0, если char, то '\0', если указатель на Т, то (Т*) NULL.

[] [] []



Описание перечисления


Перечисления являются int с именованными константами.

enum_спецификатор: enum идентификатор opt { enum_список }

enum_список: перечислитель enum_список, перечислитель

перечислитель: идентификатор идентификатор = константное_выражение

Идентификаторы в enum-списке описаны как константы и могут появляться во всех местах, где требуются константы. Если не появляется ни одного перечислителя с =, то значения всех соответствующих констант начинаются с 0 и возрастают на 1 по мере чтения описания слева направо. Перечислитель с = дает ассоциированному с ним идентификатору указанное значение; последующие идентификаторы продолжают прогрессию от присвоенного значения.

Имена перечислителей должны быть отличными от имен обычных переменных. Значения перечислителей не обязательно должны быть различными.

Роль идентификатора в спецификаторе перечисления enum_спецификатор полностью аналогична роли имени класса; он именует определенный нумератор. Например:

enum color { chartreuse, burgundy, claret=20, winedark }; ... color *cp, col; ... col = claret; cp = col ... if (*cp == burgundy) ...

делает color именем типа, описывающего различные цвета, и затем описывает cp как указатель на объект этого типа. Возможные значения извлекаются из множества { 0, 1, 20, 21 }.



в программе. Оно может также


Описание - это оператор, вводящий имя в программе. Оно может также инициализировать объект с этим именем. Выполнение описания означает, что когда поток управления доходит до описания, вычисляется инициализирующее выражение (инициализатор) и производится инициализация. Например:
for (int i = 1; i




Прежде чем имя (идентификатор) может быть использовано в C++ программе, он должно быть описано. Это значит, что надо задать его тип, чтобы сообщить компилятору, к какого вида объектам относится имя. Вот несколько примеров, иллюстрирующих разнообразие описаний:
char ch; int count = 1; char* name = "Bjarne"; struct complex { float re, im; }; complex cvar; extern complex sqrt(complex); extern int error_number; typedef complex point; float real(complex* p) { return p-re; }; const double pi = 3.1415926535897932385; struct user;
Как можно видеть из этих примеров, описание может делать больше чем просто ассоциировать тип с именем. Большинство описаний являются также определениями; то есть они также определяют для имени сущность, к которой оно относится. Для ch, count и cvar этой сущностью является соответствующий объем памяти, который должен использоваться как переменная - эта память будет выделена. Для real это заданная функция. Для constant pi это значение 3.1415926535897932385. Для complex этой сущностью является новый тип. Для point это тип complex, поэтому point становится синонимом complex. Только описания
extern complex sqrt(complex); extern int error_number; struct user;
не являются одновременно определениями. Это означает, что объект, к которому они относятся, должен быть определен где-то еще. Код (тело) функции sqrt должен задаваться неким другим описанием, память для переменной error_number типа int должна выделяться неким другим описанием, и какое-то другое описание типа user должно определять, что он из себя представляет. В C++ программе всегда должно быть только одно определение каждого имени, но описаний может быть много, и все описания должны согласовываться с типом объекта, к которому они относятся, поэтому в этом фрагменте есть две ошибки:
int count; int count; // ошибка: переопределение exnern int error_number; exnern int error_number; // ошибка: несоответствие типов
а в этом - ни одной (об использовании extern см. ):
exnern int error_number; exnern int error_number;
Некотрые описания задают "значение" для сущностей, которые они определяют:
struct complex { float re, im; }; typedef complex point; float real(complex* p) { return p-re }; const double pi = 3.1415926535897932385;
Для типов, функций и констант "значение" неизменно; для неконстантных типов данных начальное значение может впоследствии изменяться:
int count = 1; char* name = "Bjarne"; //... count = 2; name = "Marian";
Из всех определений только

char ch;

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


описание: спецификаторы_описания opt список_описателей opt ; описание_имени asm-описание описание_имени: агрег идентификатор ; enum идентификатор ; агрег: class struct union asm-описание: asm ( строка ); спецификаторы_описания: спецификатор_описания спецификатор_описания opt спецификатор_описания: имя_простого_типа спецификатор_класса enum_спецификатор sc_спецификатор фнк_спецификатор typedef friend const void sc_спецификатор: auto extern register static фнк-спецификатор: inline overload virtual список_описателей: иниц-описатель иниц-описатель , список_описателей иниц-описатель: описатель инициализатор opt описатель: оп_имя ( описатель ) * const opt описатель const opt описатель описатель ( список_описаний_параметров ) описатель [ константное_выражение opt ] оп_имя: простое_оп_имя typedef-имя . простое_оп_имя простое_оп_имя: идентификатор typedef-имя - typedef-имя имя_функции_операции имя_функции_операции: операция операция список_описаний_параметров: список_описаний_прм opt ... opt список_описаний_прм : список_описаний_прм , описание_параметра описание_параметра описание_параметра: спецификаторы_описания описатель спецификаторы_описания описатель = константное_выражение спецификатор_класса: заголовок_класса {список_членов opt } заголовок_класса {список_членов opt public : список_членов opt } заголовок_класса : агрег идентификатор opt агрег идентификатор opt : public opt typedef-имя список_членов : описание_члена список_членов opt описание_члена: спецификаторы_описания opt описатель_члена ; описатель_члена: описатель идентификатор opt : константное_выражение инициализатор: = выражение = { список_инициализаторов} = { список_инициализаторов, } (список_выражений ) список_инициализаторов : выражение список_инициализаторов , список_инициализаторов { список_инициализаторов } enum-спецификатор: enum идентификатор opt { enum-список } enum-список: перечислитель enum-список , перечислитель перечислитель: идентификатор идентификатор = константное_выражение


Описания используются для определения интерпретации, даваемой каждому идентификатору; они не обязательно резервируют память, связанную с идентификатором. Описания имеют вид:
описание:
спецификаторы_описания opt список_описателей opt ; описание_имени asm_описание
Описатели в списке_описателей содержат идентификаторы, подлежащие описанию. Спецификаторы_описания могут быть опущены только в определениях внешних функций (#10) или в описаниях внешних функций. Список описателей может быть пустым только при описании класса (#8.5) или перечисления (#8.10), то есть, когда спецификаторы_описания - это class_спецификатор или enum_спецификатор. Описания имен описываются в #8.8; описания asm описаны в
спецификатор_описания: sc_спецификатор спецификатор_типа фнк_спецификатор friend typedef
спецификаторы_описания: спецификатор_описания спецификатор_описания opt
Список должен быть внутренне непротиворечив в описываемом ниже смысле.

Описания Функций


Описание функции задает имя функции, тип возвращаемого функцией значения (если таковое есть) и число и типы параметров, которые должны быть в вызове функции. Например:

extern double sqrt(double); extern elem* next_elem(); extern char* strcpy(char* to, const char* from); extern void exit(int);

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

double sr2 = sqrt(2);

будет правильно обращаться к функции sqrt() со значением с плавающей точкой 2.0. Значение такой проверки типа и преобразования типа огромно.

Описание функции может содержать имена параметров. Это может помочь читателю, но компилятор эти имена просто игнорирует.



Описания и Константы


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

- С.Н. Паркинсон

В этой главе описаны основные типы (char, int, float и т.д.) и основные способы построения из них новых типов (функций, векторов, указателей и т.д.). Имя вводится в программе посредством описания, которое задает его тип и, возможно, начальное значение. Даны понятия описания, определения, области видимости имен, времени жизни объектов и типов. Описываются способы записи констант в C++, а также способы определения символических констант. Примеры просто демонстрируют характерные черты языка. Более развернутый и реалистичный пример приводится в следующей главе для знакомства с выражениями и операторами языка C++. Механизмы задания типов, определяемых пользователем, с присоединенными операциями представлены в Главах , 5 и и здесь не упоминаются.



Описания классов


Класс специфицирует тип. Его имя становится typedef-имя (см. ), которое может быть использовано даже внутри самого спецификатора класса. Объекты класса состоят из последовательности членов.

спецификатор_класса: заголовок_класса { список_членов opt } заголовок_класса { список_членов opt public : список_членов opt }

заголовок_класса: агрег идентификатор opt агрег идентификатор opt : public opt typedef-имя агрег: class struct union

Структура является классом, все члены которого общие; см. Объединение является классом, содержащим в каждый момент только один член; см. Список членов может описывать члены вида: данные, функция, класс, определение типа, перечисление и поле. Поля обсуждаются в Список членов может также содержать описания, регулирующие видимость имен членов; см. #8.5.8.

список_членов: описание_члена список_членов opt описание_члена: спецификаторы_описания opt описатель_члена; описатель_члена: описатель идентификатор opt : константное_выражение

Члены, являющиеся классовыми объектами, должны быть объектами предварительно полностью описанных классов. В частности, класс cl не может содержать объект класса cl, но он может содержать указатель на объект класса cl.

Имена объектов в различных классах не конфликтуют между собой и с обычными переменными.

Вот простой пример описания структуры:

struct tnode { char tword[20]; int count; tnode *left; tnode *right; };

содержащей массив из 20 символов, целое и два указателя на такие же структуры. Если было дано такое описание, то описание

tnode s, *sp

описывает s как структуру данного сорта и sp как указатель на структуру данного сорта. При наличии этих описаний выражение

sp-count

ссылается на поле count структуры, на которую указывает sp;

s.left

ссылается на указатель левого поддерева структуры s; а

s.right-tword[0]

ссылается на первый символ члена tword правого поддерева структуры s.



Описанные константы


Объект () любого типа может быть определен как имеющий постоянное значение во всей области видимости () его имени. В случае указателей для достижения этого используется декларатор *const; для объектов, не являющихся указателями, используется описатель const (#8.2).



Описатели


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

список_описателей: иниц_описатель иниц_описатель , список_описателей иниц_описатель: описатель инициализатор opt

Инициализаторы обсуждаются в #8.6. Спецификатор в описании указывает тип и класс памяти объектов, к которым относятся описатели. Описатели имеют синтаксис:

описатель: оп_имя ( описатель ) * const opt описатель const opt описатель описатель ( список_описаний_параметров ) описатель [ константное_выражение opt ]

оп-имя: простое_оп_имя typedef-имя :: простое_оп_имя

простое_оп_имя: идентификатор typedef-имя ~ typedef-имя имя_функции_операции имя_функции_преобразования

Группировка та же, что и в выражениях.



Определение типа typedef


Описания, содержащие спецификатор_описания typedef, определяют идентификаторы, которые позднее могут использоваться так, как если бы они были ключевыми словами типа, именующее основные или производные типы.

typedef-имя: идентификатор

Внутри области видимости описания, содержащего typedef, каждый идентификатор, возникающий как часть какого-либо описателя, становится в этом месте синтаксически эквивалентным ключевому слову типа, которое именует тип, ассоциированный с идентификатором таким образом, как описывается в #8.4. Имя класса или перечисления также является typedef-именем. Например, после

typedef int MILES, *KLICKSP; struct complex { double re, im; };

каждая из конструкций

MILES distance; extern KLICKSP metricp; complex z, *zp;

является допустимым описанием; distance имеет тип int, metricp имеет тип "указатель на int".

typedef не вводит новых типов, но только синонимы для типов, которые могли бы быть определены другим путем. Так в приведенном выше примере distance рассматривается как имеющая в точности тот же тип, что и любой другой int объект.

Но описание класса вводит новый тип. Например:

struct X { int a; }; struct Y { int a; }; X a1; Y a2; int a3;

описывает три переменных трех различных типов.

Описание вида

описание_имени: агрег идентификатор ; enum идентификатор ;

определяет то, что идентификатор является именем некоторого (возможно, еще не определенного) класса или перечисления. Такие описания позволяют описывать классы, ссылающихся друг на друга. Например:

class vector; class matrix { ... friend matrix operator* (matrix,vector); };

class vector { ... friend matrix operator* (matrix,vector); };



Определения


Описание () является определением, за исключением тех случаев, когда оно описывает функции, не задавая тела функции (), когда оно содержит спецификатор extern (1) и в нем нет инициализатора или тела функции, или когда оно является описанием класса (#8.8).



Определения Функций


Каждая функция, вызываемая в программе, должна быть где-то определена (только один раз). Определение функции - это описание функции, в котором приводится тело функции. Например:

extern void swap(int*, int*); // описание

void swap(int*, int*) // определение { int t = *p; *p =*q; *q = t; }

Чтобы избежать расходов на вызов функции, функцию можно описать как inline (), а чтобы обеспечить более быстрый доступ к параметрам, их можно описать как register (). Оба средства могут использоваться неправильно, и их следует избегать везде где есть какие-либо сомнения в их полезности.


Определения функций имеют вид

определение_функции: спецификаторы_описания описатель_функции opt инициализатор_базового_класса opt тело_функции

Единственными cпецификаторами класса памяти (sc-cпецификаторами), допустимыми среди спецификаторов описания, являются extern, static, overload, inline и virtual. Описатель функции похож на описатель "функции, возвращающей ...", за исключением того, что он включает в себя имена формальных параметров определяемой функции.

Описатель функции имеет вид

описатель_функции: описатель ( список_описаний_параметров )

Форма списка описаний параметров определена в Единственный класс памяти, который может быть задан, это тот, при котором соответствующий фактический параметр будет скопирован, если это возможно, в регистр при входе в функцию. Если в качестве инициализатора для параметра задано константное выражение, то это значение используется как значение параметра по умолчанию.

Тело функции имеет вид

тело_функции: составной_оператор

Вот простой пример полного определения функции:

int max (int a,int b,int c) { int m = (a b) ? a : b; return (m c) ? m : c; }

Здесь int является спецификатором типа ; max (int a, int b, int c) является описателем функции ; { ... } - блок, задающий текст программы (код) оператора.

Поскольку в контексте выражения имя (точнее, имя как формальный параметр) считается означающим указатель на первый элемент массива, то описания формальных параметров, описанных как "массив из ...", корректируются так, чтобы читалось "указатель на ...".

Инициализатор базового класса имеет вид

инициализатор_базового_класса: : ( список_параметров opt )

Он используется для задания параметров конструктора базового класса в конструкторе производного класса. Например:

struct base { base (int); ... }; struct derived : base { derived (int); ... };

derived.derived (int a) : (a+1) { ... }

derived d (10);

Конструктор базового класса вызывается для объекта d с параметром 11.



Определения внешних данных


Определения внешних данных имеют вид

определение_данных: описание

Класс памяти таких данных статический.

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



Определяемое Преобразование Типа


Приведенная во введении реализация комплексных чисел слишком ограничена, чтобы она могла устроить кого-либо, поэтому ее нужно расширить. Это будет в основном повторением описанных выше методов. Например:

class complex { double re, im; public: complex(double r, double i) { re=r; im=i; }

friend complex operator+(complex, complex); friend complex operator+(complex, double); friend complex operator+(double, complex);

friend complex operator-(complex, complex); friend complex operator-(complex, double); friend complex operator-(double, complex); complex operator-() // унарный -

friend complex operator*(complex, complex); friend complex operator*(complex, double); friend complex operator*(double, complex);

// ... };

Теперь, имея описание complex, мы можем написать:

void f() { complex a(1,1), b(2,2), c(3,3), d(4,4), e(5,5); a = -b-c; b = c*2.0*c; c = (d+e)*a; }

Но писать функцию для каждого сочетания complex и double, как это делалось выше для operator+(), невыносимо нудно. Кроме того, близкие к реальности средства комплексной арифметики должны предоставлять по меньшей мере дюжину таких функций; посмотрите, например, на тип complex.



Основные Tипы


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

char short int long float double

Первые четыре типа используются для представления целых, последние два - для представления чисел с плавающей точкой. Переменная типа char имеет размер, естественный для хранения символа на данной машине (обычно, байт), а переменная типа int имеет размер, соответствующий целой арифметике на данной машине (обычно, слово). Диапазон целых чисел, которые могут быть представлены типом, зависит от его размера. В C++ размеры измеряются в единицах размера данных типа char, поэтому char по определению имеет размер единица. Соотношение между основными типами можно записать так:

= sizeof(char)

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

К основному типу можно применять прилагательное const. Это дает тип, имеющий те же свойства, что и исходный тип, за исключением того, что значение переменных типа const не может изменяться после инициализации.

const float pi = 3.14; const char plus = '+';

Символ, заключенный в одинарные кавычки, является символьной константой. Заметьте, что часто константа, определенная таким образом, не занимает память; просто там, где требуется, ее значение может использоваться непосредственно. Константа должна инициализироваться при описании. Для переменных инициализация необязательна, но настоятельно рекомендуется. Оснований для введения локальной переменной без ее инициализации очень немного.

К любой комбинации этих типов могут применяться арифметические операции:

+ (плюс, унарный и бинарный)
- (минус, унарный и бинарный)
* (умножение)
/ (деление)

А также операции сравнения:

== (равно)
!= (не равно)
(меньше)
(больше)
(меньше или равно)
= (больше или равно)

Заметьте, что целое деление дает целый результат: 7/2 есть 3. Над целыми может выполняться операция % получения остатка: 7%2 равно 1.

При присваивании и арифметических операциях C++ выполняет все осмысленные преобразования между основными типами, чтобы их можно было сочетать без ограничений:

double d = 1; int i = 1; d = d + i; i = d + i;


В C++ есть набор основных типов, которые соответствуют наиболее общим основным единицам памяти компьютера и наиболее общим основным способам их использования:

char short int int long int

для представления целых различных размеров,

float double

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

unsigned char unsigned short int unsigned int unsigned long int

для представления беззнаковых целых, логических значений, битовых массивов и т.п. Для большей компактности записи можно опускать int в комбинациях из нескольких слов, что не меняет смысла; так, long означает long int, и unsigned означает unsigned int. В общем, когда в описании опущен тип, он предполагается int. Например:

const a = 1; static x;

все определяют объект типа int.

Целый тип char наиболее удобен для хранения и обработки символов на данном компьютере; обычно это 8-битовый байт. Размеры объектов C++ выражаются в единицах размера char, поэтому по определению sizeof(char)==1. В зависимости от аппаратного обеспечения char является знаковым или беззнаковым целым. Тип unsigned char, конечно, всегда беззнаковый, и при его использовании получаются более переносимые программы, но из-за применения его вместо просто char могут возникать значительные потери в эффективности.

Причина того, что предоставляется более чем один целый тип, более чем один беззнаковый тип и более чем один тип с плавающей точкой, в том, чтобы дать возможность программисту воспользоваться характерными особенностями аппаратного обеспечения. На многих машинах между различными разновидностями основных типов существуют значительные различия в потребностях памяти, временах доступа к памяти и временах вычислений. Зная машину обычно легко, например, выбрать подходящий тип для конкретной переменной. Написать действительно переносимую программу нижнего уровня сложнее. Вот все, что гарантируется относительно размеров основных типов:

=sizeof(char)

Однако обычно разумно предполагать, что в char могут храниться целые числа в диапазоне 0...127 (в нем всегда могут храниться символы машинного набора символов), что short и int имеют не менее 16 бит, что int имеет размер, соответствующий целой арифметике, и что long имеет по меньшей мере 24 бита. Предполагать что-либо помимо этого рискованно, и даже эти эмпирические правила применимы не везде. Таблицу характеристик аппаратного обеспечения для некоторых машин можно найти в #с.2.6.

Беззнаковые (unsigned) целые типы идеально подходят для применений, в которых память рассматривается как массив битов. Использование unsigned вместо int с тем, чтобы получить еще один бит для представления положительных целых, почти никогда не оказывается хорошей идеей. Попытки гарантировать то, что некоторые значения положительны, посредством описания переменных как unsigned, обычно срываются из-за правил неявного преобразования. Например:

unsigned surprise = -1;

допустимо (но компилятор обязательно сделает предупреждение).




Объекты, описанные как символы (char), достаточны для хранения любого элемента машинного набора символов, и если принадлежащий этому набору символ хранится в символьной переменной, то ее значение равно целому коду этого символа.

В настоящий момент имеются целые трех размеров, описываемые как short int, int и long int. Более длинные целые (long int) предоставляют не меньше памяти, чем более короткие целые (short int), но при реализации или длинные, или короткие, или и те и другие могут стать эквивалентными обычным целым. "Обычные" целые имеют естественный размер, задаваемый архитектурой центральной машины; остальные размеры делаются такими, чтобы они отвечали специальным потребностям.

Каждое перечисление (#8.9) является набором именованных констант. Свойства enum идентичны свойствам int.

Целые без знака, описываемые как unsigned, подчиняются правилам арифметики по модулю 2n, где n - число бит в их представлении.

Числа с плавающей точкой одинарной (float) и двойной (double) точности в некоторых машинных реализациях могут быть синонимами.

Поскольку объекты перечисленных выше типов вполне можно интерпретировать как числа, мы будем говорить о них как об арифметических типах. Типы char, int всех размеров и enum будут собирательно называться целыми типами. Типы float и double будут собирательно называться плавающими типами.

Тип данных void (пустой) определяет пустое множество значений. Значение (несуществующее) объекта void нельзя использовать никаким образом, не могут применяться ни явное, ни неявное преобразования. Поскольку пустое выражение обозначает несуществующее значение, такое выражение такое выражение может использоваться только как оператор выражение (#9.1) или как левый операнд в выражении с запятой (#7.15). Выражение может явно преобразовываться к типу void (#7.2).



Основные выражения


Основные выражения, включающие в себя . , - , индексирование и вызовы функций, группируются слева направо.

список_выражений: выражение список_выражений , выражение id: идентификатор имя_функции_операции typedef-имя :: идентификатор typedef-имя :: имя_функции_операции первичное_выражение: id :: идентификатор константа строка this ( выражение ) первичное_выражение [ выражение ] первичное_выражение ( список_выражений opt ) первичное_выражение . id первичное_выражение - id

Идентификатор есть первичное выражение, причем соответственно описанное (). Имя_функции_операции есть идентификатор со специальным значением; см. и #8.5.1.

Операция ::, за которой следует идентификатор из файловой области видимости, есть то же, что и идентификатор. Это позволяет ссылаться на объект даже в том случае, когда его идентификатор скрыт ().

Typedef-имя () , за которым следует ::, после чего следует идентификатор, является первичным выражением. Typedef-имя должно обозначать класс (#8.5), и идентификатор должен обозначать член этого класса. Его тип специфицируется описанием идентификатора. Typedef-имя может быть скрыто именем, которое не является именем типа. В этом случае typedef-имя все равно может быть найдено и его можно использовать.

Константа является первичным выражением. Ее тип должен быть int, long или double в зависимости от ее формы.

Строка является первичным выражением. Ее тип - "массив символов". Обычно он сразу же преобразуется в указатель на ее первый символ ().

Ключевое слово this является локальной переменной в теле функции члена (см. ) . Оно является указателем на объект, для которого функция была вызвана.

Выражение, заключенное в круглые скобки, является первичным выражением, чей тип и значение те же, что и у незаключенного в скобки выражения. Наличие скобок не влияет на то, является выражение lvalue или нет.

Первичное выражение, за которым следует выражение в квадратных скобках, является первичным выражением. Интуитивный смысл - индекс. Обычно первичное выражение имеет тип "указатель на ...", индексирующее выражение имеет тип int и тип результата есть "...". Выражение Е1[Е2] идентично (по определению) выражению *((E1)+(E2)). Все тонкие места, необходимые для понимания этой записи, содержатся в этом разделе вместе с обсуждением в , соответственно, идентификаторов, * и + ; ниже, в приводятся следствия из этого.


Вызов функции является первичным выражением, за которым следуют скобки, содержащие список (возможно, пустой) разделенных запятыми выражений, составляющих фактические параметры для функции. Первичное выражение должно иметь тип "функция, возвращающая ..." или "указатель на функцию, возвращающую ...", и результат вызова функции имеет тип "...".

Каждый формальный параметр инициализируется фактическим параметром (). Выполняются стандартные (#6.6-8) и определяемые пользователем преобразования (#8.5.6). Функция может изменять значения своих формальных параметров, но эти изменения не могут повлиять на значения фактических параметров за исключением случая, когда формальный параметр имеет ссылочный тип.

Функция может быть описана как получающая меньше или больше параметров, чем специфицировано в описании функции (). Каждый фактический параметр типа float, для которого нет формального параметра, преобразуются к типу double; и, как обычно, имена массивов преобразуются к указателям. Порядок вычисления параметров не определен языком; имейте в виду различия между компиляторами.

Допустимы рекурсивные вызовы любых функций.

Первичное выражение, после которого стоит точка, за которой следует идентификатор (или идентификатор, уточненный typedef-именем с помощью операции ::) является выражением. Первое выражение должно быть объектом класса, а идентификатор должен именовать член этого класса. Значением является именованный член объекта, и оно является адресным, если первое выражение является адресным. Следует отметить, что "классовые объекты" могут быть структурами (#8.5.12) или объединениями ().

Первичное выражение, после которого стоит стрелка ( - ), за которой следует идентификатор (или идентификатор, уточненный typedef-именем с помощью операции ::) является выражением. Первое выражение должно быть указателем на объект класса, а идентификатор должен именовать член этого класса. Значение является адресом, ссылающимся на именованный член класса, на который указывает указательное выражение. Так, выражение E1-MOS есть то же, что и (*E1).MOS. Классы обсуждаются в #8.5.

Если первичное выражение дает значение типа "указатель на ..." (см. и #8.6.3), значением выражения был объект, обозначаемый ссылкой. Ссылку можно считать именем объекта; см.


Особые операции


Вызов функции

первичное_выражение ( список_выражений opt )

и индексирование

первичное_выражение [ выражение ]

считаются бинарными операциями. Именами определяющей функции являются соответственно operator() и operator[]. Обращение x(arg) интерпретируется как x.operator()(arg) для классового объекта x. Индексирование x[y] интерпретируется как x.operator[](y).

*/b>

"Язык программирования Си" Брайэна В. Кернигана и Денниса М. Ритчи. Это руководство было построено на основе "C Programming Language - Reference Manual" системы UNIX V с разрешения ATT Bell Laboratories. (прим. автора)

*/b> !!! выделить "постоянной ширины" шрифтом, которым печатаются программы и английские слова!!!

*/b> Этот термин применяется для описания использования в языке одной и той же лексемы для обозначения различных процедур; вид процедуры выбирается компилятором на основании дополнительной информации в виде числа и типа аргументов и т.п.

[] [] []



Открытие Файлов


Точные детали того, как открываются и закрываются файлы, различаются в разных операционных системах и здесь подробно не описываются. Поскольку после включения становятся доступны cin, cout и cerr, во многих (если не во всех) программах не нужно держать код для открытия файлов. Вот, однако, программа, которая открывает два файла, заданные как параметры командной строки, и копирует первый во второй:

#include

void error(char* s, char* s2) { cerr

Последовательность действий при создании ostream для именованного файла та же, что используется для стандартных потоков: (1) сначала создается буфер (здесь это делается посредством описания filebuf); (2) затем к нему подсоединяется файл (здесь это делается посредством открытия файла с помощью функции filebuf::open()); и, наконец, (3) создается сам ostream с filebuf в качестве параметра. Потоки ввода обрабатываются аналогично.

Файл может открываться в одной из двух мод:

enum open_mode { input, output };

Действие filebuf::open() возвращает 0, если не может открыть файл в соответствие с требованием. Если пользователь пытается открыть файл, которого не существует для output, он будет создан.

Перед завершением программа проверяет, находятся ли потоки в приемлемом состоянии (см. #8.4.2). При завершении программы открытые файлы неявно закрываются.

Файл можно также открыть одновременно для чтения и записи, но в тех случаях, когда это оказывается необходимо, парадигма потоков редко оказывается идеальной. Часто лучше рассматривать такой файл как вектор (гигантских размеров). Можно определить тип, который позволяет программе обрабатывать файл как вектор; см. Упражнения 8- 10.



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


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

Как уже говорилось, программа запускается вызовом main(). Когда это происходит, main() получает два параметра: указывающий число параметров, обычно называемый argc, и вектор параметров, обычно называемый argv. Параметры - это символьные строки, поэтому argv имеет тип char*[argc]. Имя программы (так, как оно стоит в командной строке) передается в качестве argv[0], поэтому argc всегда не меньше единицы. Например, в случае команды

dc 150/1.1934

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

argc 2 argv[0] "dc" argv[1] "150/1.1934"

Научиться пользоваться параметрами командной строки несложно; сложность состоит в том, как использовать их без перепрограммирования. В данном случае это оказывается совсем просто, поскольку поток ввода можно связать с символьной строкой, а не с файлом (). Например, можно заставить 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.



Параметры по Умолчанию


Часто в самом общем случае функции требуется больше параметров, чем в самом простом и более употребительном случае. Например, в библиотеке потоков есть функция hex(), порождающая строку с шестнадцатиричным представлением целого. Второй параметр используется для задания числа символов для представления первого параметра. Если число символов слишком мало для представления целого, происходит усечение, если оно слишком велико, то строка дополняется пробелами. Часто программист не заботится о числе символов, необходимых для представления целого, поскольку символов достаточно. Поэтому для нуля в качестве второго параметра определено значение "использовать столько символов, сколько нужно". Чтобы избежать засорения программы вызовами вроде hex(i,0), функция описывается так:

extern char* hex(long, int =0);

Инициализатор второго параметра является параметром по умолчанию. То есть, если в вызове дан только один параметр, в качестве второго используется параметр по умолчанию. Например:

cout

интерпретируется как

cout

и напечатает:

** 1f 20**

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

int f(int, int =0, char* =0); // ok int g(int =0, int =0, char*); // ошибка int f(int =0, int, char* =0); // ошибка

Заметьте, что в этом контексте пробел между * и = является существенным (*= является операцией присваивания):

int nasty(char*=0); // синтаксическая ошибка



Перечисления


Есть другой метод определения целых констант, который иногда более удобен, чем применение 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 // наименее значимый };

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



Перечислимые константы


Имена, описанные как перечислители, (см. #8.5) являются константами типа int.



Передача Параметров


Когда вызывается функция, дополнительно выделяется память под ее формальные параметры, и каждый формальный параметр инициализируется соответствующим ему фактическим параметром. Семантика передачи параметров идентична семантике инициализации. В частности, тип фактического параметра сопоставляется с типом формального параметра, и выполняются все стандартные и определенные пользователем преобразования типов. Есть особые правила для передачи векторов (#4.6.5), средство передавать параметр без проверки (#4.6.8) и средство для задания параметров по умолчанию (#4.6.6). Рассмотрим

void f(int val, int ref) { val++; ref++; }

Когда вызывается f(), val++ увеличивает локальную копию первого фактического параметра, тогда как ref++ увеличивает второй фактический параметр. Например:

int i = 1; int j = 1; f(i,j);

увеличивает j, но не i. Первый параметр, i, передается по значению, второй параметр, j, передается по ссылке. Как уже отмечалось в #2.3.10, использование функций, которые изменяют переданные по ссылке параметры, могут сделать программу трудно читаемой, и их следует избегать (но см. и #8.4). Однако передача большого объекта по ссылке может быть гораздо эффективнее, чем передача его по значению. В этом случае параметр можно описать как const, чтобы указать, что ссылка применяется по соображениям эффективности, а также чтобы не позволить вызываемой функции изменять значение объекта:

void f(const large arg) { // значение "arg" не может быть изменено }

Аналогично, описание параметра указателя как const сообщает читателю, что значение объекта, указываемого указателем, функцией не изменяется. Например:

extern int strlen(const char*); // из extern char* strcpy(char* to, const char* from); extern int strcmp(const char*, const char*);

Важность такой практики растет с размером программы.

Заметьте, что семантика передачи параметров отлична от семантики присваивания. Это важно для const параметров, ссылочных параметров и параметров некоторых типов, определяемых пользователем (#6.6).



Перегруженные имена функций


В тех случаях, когда для одного имени определено несколько (различных) описаний функций, это имя называется перегруженным. При использовании этого имени правильная функция выбирается с помощью сравнения типов фактических параметров с типами параметров в описаниях функций. К перегруженным именам неприменима операция получения адреса .

Из обычных арифметических преобразований, определенных в #6.6, для вызова перегруженной функции выполняются только char-short-int, int-double, int-long и float-double. Для того, чтобы перегрузить имя функции не-члена описание overload должно предшествовать любому описанию функции; см.

Например:

overload abs; int abs (int); double abs (double);

Когда вызывается перегруженное имя, по порядку производится сканирование списка функций для нахождения той, которая может быть вызвана. Например, abs(12) вызывает abs(int), а abs(12.0) будет вызывать abs(double). Если бы был зарезервирован порядок вызова, то оба обращения вызвали бы abs(double).

Если в случае вызова перегруженного имени с помощью вышеуказанного метода не найдено ни одной функции, и если функция получает параметр типа класса, то конструкторы классов параметров (в этом случае существует единственный набор преобразований, делающий вызов допустимым) применяются неявным образом. Например:

class X { ... X (int); }; class Y { ... Y (int); }; class Z { ... Z (char*); };

overload int f (X), f (Y); overload int g (X), g (Y);

f (1); /* неверно: неоднозначность f(X(1)) или f(Y(1)) */ g (1); /* g(X(1)) */ g ("asdf"); /* g(Z("asdf")) */

Все имена функций операций являются автоматически перегруженными.



Перегруженные операции


Большинство операций может быть перегружено, то есть, описано так, чтобы они получали в качестве операндов объекты классов (см. #8.5.11). Изменить приоритет операций невозможно. Невозможно изменить смысл операций при применении их к неклассовым объектам. Предопределенный смысл операций = и (унарной) при применении их к объектам классов может быть изменен.

Эквивалентность операций, применяемых к основным типам (например, ++a эквивалентно a+=1), не обязательно выполняется для операций, применяемых к классовым типам. Некоторые операции, например, присваивание, в случае применения к основным типам требуют, чтобы операнд был lvalue; это не требуется для операций, описанных для классовых типов.



Перегрузка Имен Функций


Как правило, давать разным функциям разные имена - мысль хорошая, но когда некоторые функции выполняют одинаковую работу над объектами разных типов, может быть более удобно дать им одно и то же имя. Использование одного имени для различных действий над различными типами называется перегрузкой (overloading). Метод уже используется для основных операций C++: у сложения существует только одно имя, +, но его можно применять для сложения значений целых, плавающих и указательных типов. Эта идея легко расширяется на обработку операций, определенных пользователем, то есть, функций. Чтобы уберечь программиста от случайного повторного использования имени, имя может использоваться более чем для одной функции только если оно сперва описано как перегруженное. Например:

overload print; void print(int); void print(char*);

Что касается компилятора, единственное общее, что имеют функции с одинаковым именем, это имя. Предположительно, они в каком-то смысле похожи, но в этом язык ни стесняет программиста, ни помогает ему. Таким образом, перегруженные имена функций - это главным образом удобство записи. Это удобство значительно в случае функций с общепринятыми именами вроде sqrt, print и open. Когда имя семантически значимо, как это имеет место для операций вроде +, * и #5.2.4 и #6.3.1), это удобство становится существенным. Когда вызывается перегруженная f(), компилятор должен понять, к какой из функций с именем f следует обратиться. Это делается путем сравнения типов фактических параметров с типами формальных параметров всех функций с именем f. Поиск функции, которую надо вызвать, осуществляется за три отдельных шага:

[1] Искать функцию соответствующую точно, и использовать ее, если она найдена;

[2] Искать соответствующую функцию используя встроенные преобразования и использовать любую найденную функцию; и

[3] Искать соответствующую функцию используя преобразования, определенные пользователем (#6.3), и если множество преобразований единственно, использовать найденную функцию.

Например:


overload print(double), print(int);

void f(); { print(1); print(1.0); }

Правило точного соответствия гарантирует, что f напечатает 1 как целое и 1.0 как число с плавающей точкой. Ноль, char или short точно соответствуют параметру int. Аналогично, float точно соответствует double.

К параметрам функций с перегруженными именами стандартные C++ правила преобразования (#с.6.6) применяются не полностью. Преобразования, могущие уничтожить информацию, не выполняются. Остаются int в long, int в double, ноль в long, ноль в double и преобразования указателей: ноль в указатель, ноль в void*, и указатель на производный класс в указатель на базовый класс ().

Вот пример, в котором преобразование необходимо:

overload print(double), print(long);

void f(int a); { print(a); }

Здесь a может быть напечатано или как double, или как long. Неоднозначность разрешается явным преобразованием типа (или print(long(a)) или print(double(a))).

При этих правилах можно гарантировать, что когда эффективность или точность вычислений для используемых типов существенно различаются, будет использоваться простейший алгоритм (функция). Например:

overload pow; int pow(int, int); double pow(double, double); // из complex pow(double, complex); // из complex pow(complex, int); complex pow(complex, double); complex pow(complex, complex);

Процесс поиска подходящей функции игнорирует unsigned и const.


Перегрузка операций


Настоящий класс ostream определяет операцию Чтобы определить @, где @ - некоторая операция языка C++, для каждого определяемого пользователем типа вы определяете функцию с именем operator@, которая получает параметры соответствующего типа. Например:

class ostream { //... ostream operator

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

s1 == my_out

Первая очевидная польза от ссылок состоит в том, чтобы обеспечить передачу адреса объекта, а не самого объекта, в функцию вывода (в некоторых языках это называется передачей параметра по ссылке):

ostream operator

Достаточно интересно, что тело функции осталось без изменений, но если вы будете осуществлять присваивание s, то будете воздействовать на сам объект, а не на его копию. В данном случае то, что возвращается ссылка, также повышает эффективность, поскольку очевидный способ реализации ссылки - это указатель, а передача указателя гораздо дешевле, чем передача большой структуры данных.

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

class istream { //... int state; public: istream operator(char); istream operator(char*); istream operator(int); istream operator(long); //... };

Заметьте, что для чтения long и int используются разные функции, тогда как для их печати требовалась только одна. Это вполне обычно, и причина в том, что int может быть преобразовано в long по стандартным правилам неявного преобразования (#с.6.6), избавляя таким образом программиста от беспокойства по поводу написания обеих функций ввода.


Здесь водятся Драконы! - старинная карта

В этой главе описывается аппарат, предоставляемый в C++ для перегрузки операций. Программист может определять смысл операций при их применении к объектам определенного класса. Кроме арифметических, можно определять еще и логические операции, операции сравнения, вызова () и индексирования [], а также можно переопределять присваивание и инициализацию. Можно определить явное и неявное преобразование между определяемыми пользователем и основными типами. Показано, как определить класс, объект которого не может быть никак иначе скопирован или уничтожен кроме как специальными определенными пользователем функциями.



Плавающие и целые


Преобразования плавающих значений в интегральный тип имеет склонность быть машинно зависимым. В частности, направление усечения отрицательных чисел различается от машины к машине. Если предоставляемого пространства для значения не хватает, то результат не определен.

Преобразование интегрального значения в плавающий тип выполняются хорошо. При нехватке в аппаратной реализации требуемых бит возникает некоторая потеря точности.