## 1. Введение

Язык программирования C++ - это C*1, расширенный введением классов, inline-функций, перегруженных операций, перегруженных имен функций, константных типов, ссылок, операций управления свободной памятью, проверки параметров функций. Коротко различия между С++ и "старым С" приведены в #15. В этом руководстве описывается язык по состоянию на Июнь 1985.

## 2. Договоренности о Лексике

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

### 2.1 Комментарии

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

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

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

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

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

      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 зарезервированы для применения в будущем.

### 2.4 Константы

| 2.4.1 Целые константы
| 2.4.2 Явно заданные длинные константы
| 2.4.3 Символьные константы
| 2.4.4 Константы с плавающей точкой
| 2.4.5 Перечислимые константы
| 2.4.6 Описанные константы

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

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

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

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

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

#### 2.4.3 Символьные константы

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

символ новой строки | NL(LF) | \n
горизонтальная табуляция | NT | \t
вертикальная табуляция | VT | \v
возврат на шаг | BS | \b
возврат каретки | CR | \r
перевод формата | FF | \f
обратная косая | \ | \\
одиночная кавычка (апостроф) | ' | \'
набор битов | 0ddd | \ddd
набор битов | 0xddd | \xddd

Escape-последовательность \ddd состоит из обратной косой, за которой следуют 1, 2 или 3 восьмеричных цифры, задающие значение требуемого символа. Специальным случаем такой конструкции является \0 (не следует ни одной цифры), задающая пустой символ NULL. Escape-последовательность \xddd состоит из обратной косой, за которой следуют 1, 2 или 3 шестнадцатиричных цифры, задающие значение требуемого символа. Если следующий за обратной косой символ не является одним из перечисленных, то обратная косая игнорируется.

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

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

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

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

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

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

### 2.5 Строки

Строка есть последовательность символов, заключенная в двойные кавычки: "...". Строка имеет тип "массив символов" и класс памяти static (см. #4), она инициализируется заданными символами. Все строки, даже если они записаны одинаково, различны. Компилятор располагает в конце каждой строки нулевой (пустой) байт \0 с тем, чтобы сканирующая строку программа могла найти ее конец. В строке перед символом двойной кавычки " обязательно должен стоять \; кроме того, могут использоваться те же escape-последовательности, что были описаны для символьных констант. И, наконец, символ новой строки может появляться только сразу после \; тогда оба, - \ и символ новой строки, - игнорируются.

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

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

    _____________________________________________________________
    |           DEC VAX-11 Motorola 68000 IBM 370     AT&T 3B   |
    |            ASCII        ASCII       EBCDIC       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 |  знаковый | без знака | без знака | без знака  |
    | тип поля |  знаковый | без знака | без знака | без знака  |
    | порядок  |  справа   | слева     |  слева    | слева      |
    |  полей   |   налево  |  направо  |   направо |  направо   |
    |__________|___________|___________|___________|____________|

## 3. Запись Синтаксиса

По используемым в данном руководстве синтаксическим правилам записи синтаксические категории выделяются курсивом а литеральные слова и символы шрифтом постоянной ширины*2 . Альтернативные категории записываются на разных строках. Необязательный терминальный или нетерминальный символ обозначается нижним индексом "opt", так что

      { выражение opt }

указывает на необязательность выражения в фигурных скобках. Синтаксис кратко изложен в #14.

## 4. Имена и Типы

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

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

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

Локальная: | Имя, описанное в блоке (#9.2), локально в этом блоке и может использоваться только в нем после места описания и в охватываемых блоках. Исключение составляют метки (#9.12), которые могут использоваться в любом месте функции, в которой они описаны. Имена формальных параметров функции рассматриваются так, как если бы они были описаны в самом внешнем блоке этой функции.
Файл: | Имя, описанное вне любого блока (#9.2) или класса (#8.5), может использоваться в файле, где оно описано, после места описания.
Класс: | Имя члена класса локально для его класса и может использоваться только в функции члене этого класса (#8.5.2), после примененной к объекту его класса (#7.1) операции . или после примененной к указателю на объект его класса (#7.1) операции ->. На статические члены класса (#8.5.1) и функции члены можно также ссылаться с помощью операции :: там, где имя их класса находится в области видимости. Класс, описанный внутри класса (#8.5.15), не считается членом, и его имя принадлежит охватывающей области видимости.

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

### 4.2 Определения

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

### 4.3 Компоновка

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

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

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

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

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

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

### 4.5 Основные типы

Объекты, описанные как символы (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).

### 4.4 Производные типы

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

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

В целом эти способы конструирования объектов могут применяться рекурсивно.
Объект типа void* (указатель на void) можно использовать для указания на объекты неизвестного типа.

## 5. Объекты и lvalue(адреса)

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

## 6. Преобразования

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

### 6.1 Символы и целые

Символ или короткое целое могут использоваться, если может использоваться целое. Во всех случаях значение преобразуется к целому. Преобразование короткого целого к длинному всегда включает в себя знаковое расширение; целые являются величинами со знаком. Содержат символы знаковый разряд или нет, является машинно зависимым; см. #2.6. Более явный тип unsigned char ограничивает изменение значения от 0 до машинно зависимого максимума.
В машинах, где символы рассматриваются как имеющие знак (знаковые), символы множества кода ASCII являются положительными. Однако, символьная константа, заданная восьмеричной esc- последовательностью подвергается знаковому расширению и может стать отрицательным числом; так например, '\377' имеет значение -1.
Когда длинное целое преобразуется в короткое или в char, оно урезается влево; избыточные биты просто теряются.

### 6.2 Float и double

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

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

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

### 6.4 Указатели и целые

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

### 6.5 Unsigned

Всегда при сочетании целого без знака и обычного целого обычное целое преобразуется к типу unsigned и результат имеет тип unsigned. Значением является наименьшее целое без знака, равное целому со знаком (mod 2**(размер слова)) (т.е. по модулю 2**(размер слова)). В дополнительном двоичном представлении это преобразование является пустым, и никаких реальных изменений в двоичном представлении не происходит.
При преобразовании целого без знака в длинное значение результата численно совпадает со значением целого без знака. Таким образом, преобразование сводится к дополнению нулями слева.

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

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

| Во-первых, любые операнды типа char, unsigned char или short преобразуются к типу int.
| Далее, если один из операндов имеет тип double, то другой преобразуется к типу double и тот же тип имеет результат.
| Иначе, если один из операндов имеет тип unsigned long, то другой преобразуется к типу unsigned long и таков же тип результата.
| Иначе, если один из операндов имеет тип long, то другой преобразуется к типу long и таков же тип результата.
| Иначе, если один из операндов имеет тип unsigned, то другой преобразуется к типу unsigned и таков же тип результата.
| Иначе оба операнда должны иметь тип int и таков же тип результата.

### 6.7 Преобразования указателей

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

| Константа 0 может преобразовываться в указатель, и гарантируется, что это значение породит указатель, отличный от указателя на любой объект.
| Указатель любого типа может преобразовываться в void*.
| Указатель на класс может преобразовываться в указатель на открытый базовый класс этого класса; см. #8.5.3.
| Имя вектора может преобразовываться в указатель на его первый элемент.
| Идентификатор, описанный как "функция, возвращающая ...", всегда, когда он не используется в позиции имени функции в вызове, преобразуется в "указатель на функцию, возвращающую ...".

### 6.8 Преобразования ссылок

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

Ссылка на класс может преобразовываться в ссылку на открытый базовый класс этого класса; см. #8.6.3.

## 7. ВЫРАЖЕНИЯ

Приоритет операций в выражениях такой же, как и порядок главных подразделов в этом разделе, наибольший приоритет у первого. Так например, выражения, о которых говорится как об операндах операции + (#7.4) - это те выражения, которые определены в ##7.1-7.4.Внутри каждого подраздела операции имеют одинаковый приоритет. В каждом подразделе для рассматриваемых в нем операций определяется их левая или правая ассоциативность (порядок обработки операндов). Приоритет и ассоциативность всех операций собран вместе в описании грамматики в ##14.
В остальных случаях порядок вычисления выражения не определен. Точнее, компилятор волен вычислять подвыражения в том порядке, который он считает более эффективным, даже если подвыражения вызывают побочные эффекты. Порядок возникновения побочных эффектов не определен. Выражения, включающие в себя коммутативные и ассоциативные операции (*, +, &, |, ^), могут быть реорганизованы произвольным образом, даже при наличии скобок; для задания определенного порядка вычисления выражения необходимо использовать явную временную переменную.
Обработка переполнения и контроль деления при вычислении выражения машинно зависимы. В большинстве существующих реализаций C++ переполнение целого игнорируется; обработка деления на 0 и всех исключительных ситуаций с числами с плавающей точкой различаются от машины к машине и обычно могут регулироваться библиотечными функциями.
Кроме стандартного значения, описанного в ##7.2-7.15, операции могут быть перегружены*3, то есть, могут быть заданы их значения для случая их применения к типам, определяемым пользователем; см. #7.16.

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

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

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

Идентификатор есть первичное выражение, причем соответственно описанное (#8). Имя_функции_операции есть идентификатор со специальным значением; см. #7.16 и #8.5.1.
Операция ::, за которой следует идентификатор из файловой области видимости, есть то же, что и идентификатор. Это позволяет ссылаться на объект даже в том случае, когда его идентификатор скрыт (#4.1).
Typedef-имя (#8.8) , за которым следует ::, после чего следует идентификатор, является первичным выражением. Typedef-имя должно обозначать класс (#8.5), и идентификатор должен обозначать член этого класса. Его тип специфицируется описанием идентификатора. Typedef-имя может быть скрыто именем, которое не является именем типа. В этом случае typedef-имя все равно может быть найдено и его можно использовать.
Константа является первичным выражением. Ее тип должен быть int, long или double в зависимости от ее формы.
Строка является первичным выражением. Ее тип - "массив символов". Обычно он сразу же преобразуется в указатель на ее первый символ (#6.7).
Ключевое слово this является локальной переменной в теле функции члена (см. #8.5) . Оно является указателем на объект, для которого функция была вызвана.
Выражение, заключенное в круглые скобки, является первичным выражением, чей тип и значение те же, что и у незаключенного в скобки выражения. Наличие скобок не влияет на то, является выражение lvalue или нет.
Первичное выражение, за которым следует выражение в квадратных скобках, является первичным выражением. Интуитивный смысл - индекс. Обычно первичное выражение имеет тип "указатель на ...", индексирующее выражение имеет тип int и тип результата есть "...". Выражение Е1[Е2] идентично (по определению) выражению *((E1)+(E2)). Все тонкие места, необходимые для понимания этой записи, содержатся в этом разделе вместе с обсуждением в ## 7.1, 7.2 и 7.4, соответственно, идентификаторов, * и + ; ниже, в #8.4.2 приводятся следствия из этого.
Вызов функции является первичным выражением, за которым следуют скобки, содержащие список (возможно, пустой) разделенных запятыми выражений, составляющих фактические параметры для функции. Первичное выражение должно иметь тип "функция, возвращающая ..." или "указатель на функцию, возвращающую ...", и результат вызова функции имеет тип "...".
Каждый формальный параметр инициализируется фактическим параметром (#8.6). Выполняются стандартные (#6.6-8) и определяемые пользователем преобразования (#8.5.6). Функция может изменять значения своих формальных параметров, но эти изменения не могут повлиять на значения фактических параметров за исключением случая, когда формальный параметр имеет ссылочный тип.
Функция может быть описана как получающая меньше или больше параметров, чем специфицировано в описании функции (#8.4). Каждый фактический параметр типа float, для которого нет формального параметра, преобразуются к типу double; и, как обычно, имена массивов преобразуются к указателям. Порядок вычисления параметров не определен языком; имейте в виду различия между компиляторами.
Допустимы рекурсивные вызовы любых функций.
Первичное выражение, после которого стоит точка, за которой следует идентификатор (или идентификатор, уточненный typedef-именем с помощью операции ::) является выражением. Первое выражение должно быть объектом класса, а идентификатор должен именовать член этого класса. Значением является именованный член объекта, и оно является адресным, если первое выражение является адресным. Следует отметить, что "классовые объекты" могут быть структурами (#8.5.12) или объединениями (#8.5.13).
Первичное выражение, после которого стоит стрелка ( -> ), за которой следует идентификатор (или идентификатор, уточненный typedef-именем с помощью операции ::) является выражением. Первое выражение должно быть указателем на объект класса, а идентификатор должен именовать член этого класса. Значение является адресом, ссылающимся на именованный член класса, на который указывает указательное выражение. Так, выражение E1->MOS есть то же, что и (*E1).MOS. Классы обсуждаются в #8.5.
Если первичное выражение дает значение типа "указатель на ..." (см. #8.4 и #8.6.3), значением выражения был объект, обозначаемый ссылкой. Ссылку можно считать именем объекта; см. #8.6.3.

### 7.2 Унарные операции

| 7.2.1 Увеличение и Уменьшение
| 7.2.2 Sizeof
| 7.2.3 Явное Преобразование Типа
| 7.2.4 Свободная Память

Выражения с унарными операциями группируют справа налево:

         унарное_выражение:
              унарная_операция                                выражение
              выражение                                              ++
              выражение                                              --
              sizeof                                          выражение
              sizeof             (              имя_типа              )
              (            имя_типа             )             выражение
              простое_имя_типа       (        список_выражений        )
              new               имя_типа       инициализатор        opt
              new              (               имя_типа               )
              delete                                          выражение
              delete [ выражение ] выражение
         унарная_операция:                   одна                    из
              *  &  -  !  ~  ++  --

Унарная операция * означает косвенное обращение: выражение должно быть указателем и результатом будет lvalue, ссылающееся на объект, на который указывает выражение. Если выражение имеет тип "указатель на ...", то тип результата есть "...".
Результатом унарной операции & является указатель на объект, на который ссылается операнд. Операнд должен быть lvalue. Если выражение имеет тип "...", то тип результата есть "указатель на ...".
Результатом унарной операции + является значение ее операнда после выполнения обычных арифметических преобразований. Операнд должен быть арифметического типа.
Результатом унарной операции - является отрицательное значение ее операнда. Операнд должен иметь целый тип. Выполняются обычные арифметические преобразования. Отрицательное значение беззнаковой величины вычисляется посредством вычитания ее значения из 2n, где n -число битов в целом типа int.
Результатом операции логического отрицания ! является 1, если значение операнда 0, и 0, если значение операнда не 0. Результат имеет тип int. Применима к любому арифметическому типу или к указателям.
Операция ~ дает дополнение значения операнда до единицы. Выполняются обычные арифметические преобразования. Операнд должен иметь интегральный тип.

#### 7.2.1 Увеличение и Уменьшение

Операнд префиксного ++ получает приращение. Операнд должен быть адресным . Значением является новое значение операнда, но оно не адресное. Выражение ++x эквивалентно x+=1. По поводу данных о преобразованиях см. обсуждение операций сложения (#7.4) и присваивания (#7.14).
Операнд префиксного -- уменьшается аналогично действию префиксной операции ++.
Значение, получаемое при использовании постфиксного ++, есть значение операнда. Операнд должен быть адресным. После того, как результат отмечен, объект увеличивается так же, как и в префиксной операции ++. Тип результата тот же, что и тип операнда.
Значение, получаемое при использовании постфиксной --, есть значение операнда. Операнд должен быть адресным. После того, как результат отмечен, объект увеличивается так же, как и в префиксной операции ++. Тип результата тот же, что и тип операнда.

#### 7.2.2 Sizeof

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

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

Простое_имя_типа (#8.2), возможно, заключенное в скобки, за которым идет заключенное в скобки выражение (или список_выражений, если тип является классом с соответствующим образом описанным конструктором #8.5.5) влечет преобразование значения выражения в названный тип. Чтобы записать преобразование в тип, не имеющий простого имени, имя_типа (#8.7) должно быть заключено в скобки. Если имя типа заключено в скобки, выражение заключать в скобки необязательно. Такая запись называется приведением к типу.
Указатель может быть явно преобразован к любому из интегральных типов, достаточно по величине для его хранения. То, какой из int и long требуется, является машинно зависимым. Отобразующая функция также является машинно зависимой, но предполагается, что она не содержит сюрпризов для того, кто знает структуру адресации в машине. Подробности для некоторых конкретных машин были приведены в #2.6.
Объект интегрального типа может быть явно преобразован в указатель. Отображающая функция всегда превращает целое, полученное из указателя, обратно в тот же указатель, но в остальных случаях является машинно зависимой.
Указатель на один тип может быть явно преобразован в указатель на другой тип. Использование полученного в результате указателя может привести к исключительной ситуации адресации, если исходный указатель не указывает на объект, соответствующим образом выравненный в памяти. Гарантируется, что указатель на объект данного размера может быть преобразован в указатель на объект меньшего размера и обратно без изменений. Различные машины могут различаться по числу бит в указателях и требованиям к выравниванию объектов. Составные объекты выравниваются по самой строгой границе, требуемой каким-либо из его составляющих.
Объект может преобразовываться в объект класса только если был описан соответствующий конструктор или операция преобразования (#8.5.6).
Объект может явно преобразовываться в ссылочный тип &X, если указатель на этот объект может явно преобразовываться в X*.

#### 7.2.4 Свободная Память

Операция new создает объект типа имя_типа (см. #8.7), к которому он применен. Время жизни объекта, созданного с помощью new, не ограничено областью видимости, в которой он создан. Операция new возвращает указатель на созданный ей объект. Когда объект является массивом, возвращается указатель на его первый элемент. Например, и new int и new int[10] возвращают int*. Для объектов некоторых классов надо предоставлять инициализатор (#8.6.2). Операция new (#7.2) для получения памяти вызывает функцию

      void* operator new (long);

Параметр задает требуемое число байтов. Память будет инициализирована. Если operator new() не может найти требуемое количество памяти, то она возвращает ноль.
Операция delete уничтожает объект, созданный операцией new. Ее результат является void. Операнд delete должен быть указателем, возвращенным new. Результат применения delete к указателю, который не был получен с помощью операции new. Однако уничтожение с помощью delete указателя со значением ноль безвредно.
Чтобы освободить указанную память, операция delete вызывает функцию

       void operator delete (void*);

В форме

      delete [ выражение ] выражение

второй параметр указывает на вектор, а первое выражение задает число элементов этого вектора. Задание числа элементов является избыточным за исключением случаев уничтожения векторов некоторых классов; см. #8.5.8.

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

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

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

          выражение * выражение
          выражение  /  выражение
          выражение  % выражение

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

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

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

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

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

Результатом операции + является сумма операндов. Можно суммировать указатель на объект массива и значение целого типа. Последнее во всех случаях преобразуется к смещению адреса с помощью умножения его на длину объекта, на который указывает указатель. Результатом является указатель того же типа, что и исходный указатель, указывающий на другой объект того же массива и соответствующим образом смещенный от первоначального объекта. Так, если P есть указатель на объект массива, то выражение P+1 есть указатель на следующий объект массива.
Никакие другие комбинации типов для указателей не допустимы.
Операция + ассоциативна и выражение с несколькими умножениями на одном уровне может быть реорганизовано компилятором.
Результатом операции - является разность операндов. Выполняются обычные арифметические преобразования. Кроме того, значение любого целого типа может вычитаться из указателя, в этом случае применяются те же преобразования, что и к сложению.
Если вычитаются указатели на объекты одного типа, то результат преобразуется (посредством деления на длину объекта) к целому, представляющему собой число объектов, разделяющих объекты, указанные указателями. В зависимости от машины результирующее целое может быть или типа int, или типа long; см. #2.6. Вообще говоря, это преобразование будет давать неопределенный результат кроме тех случаев, когда указатели указывают на объекты одного массива, поскольку указатели, даже на объекты одинакового типа, не обязательно различаются на величину, кратную длине объекта.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

### 7.13 Условная операция

условное_выражение:

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

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

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

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

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

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

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

          =  +=  -=  *=  /=  %=  >>=  <<= &="~=" |="</pre">

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

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

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

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

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

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

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

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

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

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

| 7.16.1 Унарные операции
| 7.16.2 Бинарные операции
| 7.16.3 Особые операции

Большинство операций может быть перегружено, то есть, описано так, чтобы они получали в качестве операндов объекты классов (см. #8.5.11). Изменить приоритет операций невозможно. Невозможно изменить смысл операций при применении их к неклассовым объектам. Предопределенный смысл операций = и & (унарной) при применении их к объектам классов может быть изменен.
Эквивалентность операций, применяемых к основным типам (например, ++a эквивалентно a+=1), не обязательно выполняется для операций, применяемых к классовым типам. Некоторые операции, например, присваивание, в случае применения к основным типам требуют, чтобы операнд был lvalue; это не требуется для операций, описанных для классовых типов.

#### 7.16.1 Унарные операции

Унарная операция, префиксная или постфиксная, может быть определена или с помощью функции члена (см. #8.5.4), не получающей параметров, или с помощью функции друга (см. #8.5.10), получающей один параметр, но не двумя способами одновременно. Так, для любой унарной операции @, x@ и @x могут интерпретироваться как x.операция@() или операция@(x). При перегрузке операций ++ и -- невозможно различить префиксное и постфиксное использование.

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

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

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

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

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

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

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

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

*1 "Язык программирования Си" Брайэна В. Кернигана и Денниса М. Ритчи. Это руководство было построено на основе "C Programming Language - Reference Manual" системы UNIX V с разрешения AT&T Bell Laboratories. (прим. автора)
*2 !!! выделить "постоянной ширины" шрифтом, которым печатаются программы и английские слова!!!
*3 Этот термин применяется для описания использования в языке одной и той же лексемы для обозначения различных процедур; вид процедуры выбирается компилятором на основании дополнительной информации в виде числа и типа аргументов и т.п.

[Назад] [Содержание] [Вперед]