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

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

Из обычных арифметических преобразований, определенных в , для вызова перегруженной функции выполняются только 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")) */

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

Аддитивные операции

Аддитивные операции + и - группируют слева направо. Выполняюься обычные арифметические преобразования. Каждая операция имеет некоторые дополнительные возможности, связанные с типами.

аддитивное_выражение: выражение + выражение выражение - выражение

Результатом операции + является сумма операндов. Можно суммировать указатель на объект массива и значение целого типа. Последнее во всех случаях преобразуется к смещению адреса с помощью умножения его на длину объекта, на который указывает указатель. Результатом является указатель того же типа, что и исходный указатель, указывающий на другой объект того же массива и соответствующим образом смещенный от первоначального объекта. Так, если P есть указатель на объект массива, то выражение P+1 есть указатель на следующий объект массива.

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

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

Результатом операции - является разность операндов. Выполняются обычные арифметические преобразования. Кроме того, значение любого целого типа может вычитаться из указателя, в этом случае применяются те же преобразования, что и к сложению.

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

Арифметические преобразования

Большое количество операций вызывают преобразования и дают тип результата одинаковым образом. Этот стереотип будет называться "обычным арифметическим преобразованием".

Во-первых, любые операнды типа char, unsigned char или short преобразуются к типу int.

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

Иначе, если один из операндов имеет тип unsigned long, то другой преобразуется к типу unsigned long и таков же тип результата.

Иначе, если один из операндов имеет тип long, то другой преобразуется к типу long и таков же тип результата.

Иначе, если один из операндов имеет тип unsigned, то другой преобразуется к типу unsigned и таков же тип результата.

Иначе оба операнда должны иметь тип int и таков же тип результата.

Бинарные операции

Бинарная операция может быть определена или с помощью функции члена (см. ), получающей один параметр, или с помощью функции друга (см. ), получающей два параметра, но не двумя способами одновременно. Так, для любой бинарной операции @, x@y может быть проинтерпретировано как x.операция@(y) или операция@(x,y).

Целые константы

Целая константа, состоящая из последовательности цифр, считается восьмеричной, если она начинается с 0 (цифры ноль), и десятичной в противном случае. Цифры 8 и 9 не являются восьмеричными цифрами. Последовательность цифр, которой предшествует 0х или 0Х, воспринимается как шестнадцатеричное целое. В шестнадцатеричные цифры входят буквы от а или А до f или F, имеющие значения от 10 до 15. Десятичная константа, значение которой превышает наибольшее машинное целое со знаком, считается длинной (long); восьмеричная и шестнадцатеричная константа, значение которой превышает наибольшее машинное целое со знаком, считается long; в остальных случаях целые константы считаются int.

Деструкторы

Функция член класса cl с именем ~cl называется деструктором. Деструктор не возвращает никакого значения и не получает никаких параметров; он используется для уничтожения значений типа cl непосредственно перед уничтожением содержащего их объекта. Деструктор не может быть overload, virtual или friend.

Деструктор для базового класса выполняется после деструктора производного от него класса. Как деструкторы используются для управления свободной памятью, см. объяснение в .

Договоренности о лексике

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

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

Друзья (friends)

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

class private { int a; friend void friend_set (private*,int); public: void member_set (int); };

void friend_set (private* p,int i) { p-a=i; }

void private.member_set (int i) { a = i; }

private obj;

friend_set (obj,10);

obj.member_set (10);

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

class cl2 { friend cl1; . . . };

Float и doublе

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

Функции

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

typedef int (*PF) (); extern g (PF); extern f (); ... g (f);

Тогда определение g может иметь следующий вид:

g (PF funcp) { ... (*funcp) (); ... }

Заметьте, что f должна быть описана явно в вызывающей программе, поскольку ее появление в g(f) не сопровождалось (.

Функции члены

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

struct tnode { char tword[20]; int count; tnode *left; tnode *right; void set (char* w,tnode* l,tnode* r); };

tnode n1, n2;

n1.set ("asdf",n2,0); n2.set ("ghjk",0,0);

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

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

см. 3.3. Определения функций обсуждаются в . Например:

void tnode.set (char* w,tnode* l,tnode* r) { count = strlen (w); if (sizeof (tword)

Имя функции tnode.set определяет то, что множество функций является членом класса tnode. Это позволяет использовать имена членов word, count, left и right. В функции члене имя члена ссылается на объект, для которого была вызвана функция. Так, в вызове n1.set(...) tword ссылается на n1.tword, а в вызове n2.set(...) он ссылается на n2.tword. В этом примере предполагается, что функции strlen, error и strcpy описаны где-то в другом месте как внешние функции (см. ).

В члене функции ключевое слово this указывает на объект, для которого вызвана функция. Типом this в функции, которая является членом класса cl, является cl*. Если mem - член класса cl,то mem и this-mem - синонимы в функции члене класса cl (если mem не был использован в качестве имени локальной переменной в промежуточной области видимости).

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

int b; struct x { int f () { return b; } int f () { return b; } int b; };

означает

int b; struct x { int f (); int b; }; inline x.f () { return b; }

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

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

Функция операция

Большинство операций могут быть перегружены с тем, чтобы они могли получать в качестве операндов объекты класса.

имя_функции_операции: operator op op: + - * / % ^ | ~ ! = += -= *= /= %= ^= = |= = == != = ++ -- () []

Последние две операции - это вызов функции и индексирование. Функция операция может или быть функцией членом, или получать по меньшей мере один параметр класса. См. также .

Харктеристики аппаратного обеспечения

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

	DEC VAX-11 ASCII	Motorola 68000 ASCII	IBM 370 EBCDIC	ATT 3B ASCII
char	8 бит	8 бит	8 бит	8 бит
int	32 бит	16 бит	32 бит	16 бит
short	16 бит	16 бит	16 бит	16 бит
long	32 бит	32 бит	32 бит	32 бит
float	32 бит	32 бит	32 бит	32 бит
double	64 бит	64 бит	64 бит	64 бит
указатель	32 бит	32 бит	24 бит	32 бит
диапазон float	+_10E+_38	+_10E+_38	+_10E+_76	+_10E+_38
диапазон double	+_10E+_38	+_10E+_38	+_10E+_76	+_10E+_308
тип char	знаковый	без знака	без знака	без знака
тип поля	знаковый	без знака	без знака	без знака
порядок	справа	слева	слева	слева
полей	налево	направо	направо	направо

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

Идентификаторы (имена)

Идентификатор - последовательность букв и цифр произвольной длины; первый символ обязан быть буквой; подчерк '_' считается за букву; буквы в верхнем и нижнем регистрах являются различными.

Имена и типы

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

Имена типов

Иногда (для неявного задания преобразования типов и в качестве параметра sizeof или new) нужно использовать имя типа данных. Это выполняется при помощи "имени типа" которое по сути является описанием для объекта этого типа, в котором опущено имя объекта.

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

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

int int * int *[3] int *() int (*)()

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

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

простое_имя_типа: typedef-имя char short int long unsigned float double

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

(double) a

может быть также записано как

double (a)

Инициализация

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

инициализатор: = expression = { список_инициализаторов } = { список_инициализаторов , } ( список_выражений )

список_инициализаторов : выражение список_инициализаторов , список_инициализаторов { список_инициализаторов }

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

Гарантируется, что неинициализированные статические и внешние переменные получают в качестве начального значения "пустое значение". Когда инициализатор применяется к скаляру (указатель или объект арифметического типа), он состоит из одного выражения, возможно, заключенного в фигурные скобки. Начальное значение объекта находится из выражения; выполняются те же преобразования, что и при присваивании.

Заметьте, что поскольку () не является инициализатором, то "X a();" является не описанием объекта класса X, а описанием функции, не получающей значений и возвращающей X.

Явно заданные длинные константы

Десятичная, восьмеричная или шестнадцатеричная константа, за которой непосредственно стоит l (латинская буква "эль") или L, считается длинной константой.

Явное Преобразование Типа

Простое_имя_типа (), возможно, заключенное в скобки, за которым идет заключенное в скобки выражение (или список_выражений, если тип является классом с соответствующим образом описанным конструктором ) влечет преобразование значения выражения в названный тип. Чтобы записать преобразование в тип, не имеющий простого имени, имя_типа () должно быть заключено в скобки. Если имя типа заключено в скобки, выражение заключать в скобки необязательно. Такая запись называется приведением к типу.

Указатель может быть явно преобразован к любому из интегральных типов, достаточно по величине для его хранения. То, какой из int и long требуется, является машинно-зависимым. Отображающая функция также является машинно-зависимой, но предполагается, что она не содержит сюрпризов для того, кто знает структуру адресации в машине. Подробности для некоторых конкретных машин были приведены в .

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

Указатель на один тип может быть явно преобразован в указатель на другой тип. Использование полученного в результате указателя может привести к исключительной ситуации адресации, если исходный указатель не указывает на объект, соответствующим образом выравненный в памяти. Гарантируется, что указатель на объект данного размера может быть преобразован в указатель на объект меньшего размера и обратно без изменений. Различные машины могут различаться по числу бит в указателях и требованиям к выравниванию объектов. Составные объекты выравниваются по самой строгой границе, требуемой каким-либо из его составляющих.

Объект может преобразовываться в объект класса только если был описан соответствующий конструктор или операция преобразования ().

Объект может явно преобразовываться в ссылочный тип X, если указатель на этот объект может явно преобразовываться в X*.

Явные преобразования указателей

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

Указатель иожет быть преобразован к любому из целых типов, достаточно больших для его хранения. То, какой из int и long требуется, является машинно-зависимым. Преобразующая функция также является машинно-зависимой, но предполагается, что она не содержит сюрпризов для того, кто знает структуру адресации в машине. Подробности для некоторых конкретных машин были даны в .

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

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

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

extern void* alloc (); double* dp; dp = (double*) alloc (sizeof (double)); *dp= 22.0 / 7.0;

alloc должна обеспечивать (машинно-зависимым образом) то, что возвращаемое ею значение подходит для преобразования в указатель на double; в этом случае использование функции мобильно. Различные машины различаются по числу бит в указателях и требованиям к выравниванию объектов. Составные объекты выравниваются по самой строгой границе, требуемой каким-либо из его составляющих.

Классовые объекты

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

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

struct complex { float re; float im; complex (float r,float i) { re=r; im=i; } complex (float r) { re=r; im=0; } };

complex zz (1,2.3); complex* zp = new complex (1,2.3);

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

complex zz1 = complex (1,2.3); complex zz2 = complex (123); complex zz3 = 123; complex zz4 = zz3;

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

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

Классы

Классовые объекты могут присваиваться, передаваться функциям как параметры и возвращаться функциями. Другие возможные операции, как, например, проверка равенства, могут быть определены пользователем; см. .

Классы памяти

Есть два описываемых класса памяти: автоматический и статический.

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

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

Некоторые объекты не связаны с именами и их времена жизни явно управляются операторами new и delete ; см. и

Ключевые слова

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

asm auto break case char class const continue default delete do double else enum extern float for friend goto if inline int long new operator overload public register return short sizeof static struct switch this typedef union unsigned virtual void while

Идентификаторы signed и volatile зарезервированы для применения в будущем.

Командные строки компилятора

Компилятор языка C++ содержит препроцессор, способный выполнять макроподстановки, условную компиляцию и включение именованных файлов. Строки, начинающиеся с #, относятся к препроцессору. Эти строки имеют независимый от остального языка синтаксис; они могут появляться в любом месте оказывать влияние, которое распространяется (независимо от области видимости) до конца исходного файла программы.

Заметьте, что определения const и inline дают альтернативы для большинства использований #define.

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

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

Компоновка

Имя в файловой области видимости, не описанное явно как static, является общим для каждого файла многофайловой программы. Таковым же является имя функции. О таких именах говорится, что они внешние. Каждое описание внешнего имени в программе относится к тому же объекту (), функции (), классу (), перечислению () или значению перечислителя (). Типы, специфицированные во всех описаниях внешнего имени должны быть идентичны. Может быть больше одного определения типа, перечисления, inline-функции () или несоставного const (), при условии, что определения идентичны, пояляются в разных файлах и все инициализаторы являются константными выражениями (). Во всех остальных случаях должно быть ровно одно определение для внешнего имени в программе. Реализация может потребовать, чтобы составное const, использованное там, где не встречено никакого определения const, должно быть явно описано extern и иметь в программе ровно одно определение. Это же ограничение может налагаться на inline-функции.

Константные выражения

В нескольких местах C++ требует выражения, вычисление которых дает константу: в качестве границы массива (), в case выражениях (), в качестве значений параметров функции, присваиваемых по умолчанию, (), и в инициализаторах (). В первом случае выражение может включать только целые константы, символьные константы, константы, описанные как имена, и sizeof выражения, возможно, связанные бинарными операциями

+ - * / % == != =

или унарными операциями

- ~ !

или тернарными операциями

? :

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

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

Меньшая широта допустима для константных выражений после #if: константы, описанные как имена, sizeof выражения и перечислимые константы недопустимы.

Константы

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

Константы с плавающей точкой

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

Конструкторы

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

typedef-имя ( список_параметров opt )

Например,

complex zz = complex (1,2.3);

cprint (complex (7.8,1.2));

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

Конструктор может быть overload, но не virtual или friend.

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

Краткое изложение синтаксиса

Мы надеемся, что эта краткая сводка синтаксиса C++ поможет пониманию. Она не является точным изложением языка.

Массивы символов

Последняя сокращенная запись позволяет инициализировать строкой массив данных типа char. В этом случае последовательные символы строки инициализируют члены массива. Например:

char msg[] = "Syntax error on line %d\n";

демонстрирует массив символов, члены которого инициализированы строкой.

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

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

Это правило сообразным образом применяется в случае многомерного массива. Если E является n-мерным массивом ранга i*j*...*k, то возникающее в выражении E преобразуется в указатель на (n-1)-мерный массив ранга j*...*k. Если к этому указателю, явно или неявно, как результат индексирования, применяется операция *, ее результатом является (n-1)-мерный массив, на который указывалось, который сам тут же преобразуется в указатель.

Рассмотрим, например,

int x[3][5];

Здесь x - массив целых размером 3*5. Когда x возникает в выражении, он преобразуется в указатель на (первый из трех) массив из 5 целых. В выражении x[i], которое эквивалентно *(x+1), x сначала преобразуется, как описано, в указатель, затем 1 преобразуется к типу x, что включает в себя умножение 1 на длину объекта, на который указывает указатель, а именно объект из 5 целых. Результаты складываются, и используется косвенная адресация для получения массива (из 5 целых), который в свою очередь преобразуется в указатель на первое из целых. Если есть еще один индекс, снова используется тот же параметр; на этот раз результат является целым.

Именно из всего этого проистекает то, что массивы в C хранятся по строкам (быстрее всего изменяется последний индекс), и что в описании первый индекс помогает определить объем памяти, поглощаемый массивом, но не играет никакой другой роли в вычислениях индекса.

Мультипликативные операции

Мультипликативные операции *, / и % группируют слева направо. Выполняются обычные арифметические преобразования.

мультипликативное_выражение: выражение * выражение выражение / выражение выражение % выражение

Бинарная операция * определяет умножение. Операция * ассоциативна и выражения с несколькими умножениями на одном уровне могут быть реорганизованы компилятором.

Бинарная операция / определяет деление. При делении положительных целых округление осуществляется в сторону 0, но если какой-либо из операндов отрицателен, то форма округления является машинно-зависимой. На всех машинах, охватываемых данным руководством, остаток имеет тот же знак, что и делимое. Всегда истинно, что (a/b)*b + a%b равно a (если b не 0).

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

Объединения

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

Объекты и LVALUE(адреса)

Объект есть область памяти; lvalue (адрес) есть выражение, ссылающееся на объект. Очевидный пример адресного выражения - имя объекта. Есть операции, дающие адресные выражения: например, если Е - выражение типа указатель, то *Е - адресное выражение, ссылающееся на объект, на который указывает Е. Термин "lvalue" происходит из выражения присваивания Е1=Е2, в котором левый операнд Е1 должен быть адресным (value) выражением. Ниже при обсуждении каждого оператора указывается, требует ли он адресные операнды и возвращает ли он адресное значение.

Область видимости

Есть четыре вида областей видимости: локальная, файл, программа и класс.

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

Имя может быть скрыто посредством явного описания того же имени в блоке или классе. Имя в блоке или классе может быть скрыто только именем, описанным в охватываемом блоке или классе. Скрытое нелокальное имя также может использоваться, когда его область видимости указана операцией :: (). Имя класса, скрытое именем, которое не является именем типа, все равно может использоваться, если перед ним стоит class, struct или union (). Имя перечисления enum, скрытое именем, которое не является именем типа, все равно может использоваться, если перед ним стоит enum ().

Обзор типов

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

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

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

выражение_отношения: выражение выражение выражение выражение выражение = выражение

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

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

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

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

операция_присваивания: одна из = += -= *= /= %= =

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

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

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

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

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

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

Указатель может сравниваться с 0.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Оператор asм

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

asm ( строка) ;

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

| |

Оператор break

Оператор

break ;

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

Оператор contiпие

Оператор

continue ;

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

while (...) do for (...) { { { ... ... ... contin:; contin:; contin:; } } } while (...);

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

Оператор deletе

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

delete выражение ;

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

Оператор dо

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

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

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

Оператор for

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

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

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

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

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

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

Оператор gotо

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

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

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

Оператор returп

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

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

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

Оператор switch

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

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

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

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

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

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

default :

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

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

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