Это справочное руководство описывает язык программирования С++ по состоянии на май 1991. С++ - язык программирования общего назначения, базирующийся на языке программирования С Ь.

Ь "The C Programming Language" B. Kernighan, D. Ritchie. Prentice

В дополнение к возможностям С язык С++ предоставляет классы, функции подстановки, перегрузку операций, перегрузку имен функций, постоянные типы, ссылки, операторы управления свободной памятью, проверку параметров функций и приведение типов. Все расширения С суммируются в $$R.18.1. Различия между С++ и ANSI C++ приведены в $$R.18.2 Ь.

Ь American National Standard X3.159-1989. Американский национальный

Расширения С++ версии 1985 года до данного описания суммируются в $$R.18.1.2. Разделы, относящиеся к шаблонам типа ($$R.14) и управлению особыми ситуациями ($$R.15), являются местами планируемых расширений языка.

Это руководство содержит следующее: 1. Введение. 2. Соглашения о лексических понятиях. 3. Основные понятия. 4. Стандартные преобразования. 5. Выражения. 6. Операторы. 7. Описания. 8. Описатели. 9. Классы. 10. Производные классы. 11. Контроль доступа к членам. 12. Специальные функции-члены. 13. Перегрузка. 14. Шаблоны типов. 15. Управление особыми ситуациями. 16. Препроцессорная обработка.

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

означает необязательное выражение, заключенное в фигурные скобки.

Программа на С++ состоит из одного или нескольких файлов ($$R.3.3). С логической точки зрения файл транслируется за несколько проходов. Первый проход состоит в препроцессорной обработке ($$R.16), на которой происходит включение файлов и макроподстановка. Работа препроцессора управляется с помощью команд, являющихся строками, первый символ которых отличный от пробела есть # ($$R2.1). Результат работы препроцессора есть последовательность лексем. Такую последовательность лексем, т.е. файл после препроцессорной обработки, называют единицей трансляции.

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

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

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

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

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

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

Каждая операция считается отдельной лексемой.

Эти файлы являются частью ANSI стандарта для С. Кроме того заголовочные файлы

определяют типы самых важных библиотечных функций. Два последних файла входят в ANSI стандарт для С, файл <new.h> относится только к С++.

Есть несколько видов литералов (часто называемых "константами").

Все целые константы, состоящие из последовательности цифр, считаются десятичными (основание счисления десять), если только они не начинаются с 0 (цифра ноль). Последовательность цифр, начинающаяся с 0, считается восьмеричным целым (основание счисления восемь). Цифры 8 и 9 не являются восьмеричными. Последовательность цифр, начинающаяся с 0x или 0X, считается шестнадцатеричным целым (основание счисления шестнадцать). Шестандцатеричные цифры могут состоять из символов от a или A до f или F с десятичными значениями их от десяти до пятнадцати. Например, число двенадцать можно записать как 12, 014 или 0XC.

Символьной константой является один или несколько символов, заключенные в одиночные кавычки, например 'x'. Константа из одного символа имеет тип char. Значение константы из одного символа есть порядковый номер символа в таблице кодировки символов на данной машине. Символьные константы из нескольких символов имеют тип int. Значение такой константы зависит от реализации.

Если за обратной дробной чертой следует символ, отличный от перечисленных, результат неопределен. Комбинация \ooo состоит из обратной дробной черты, а которой следуют одна, две или три восьмеричные цифры. Считается, что они определяют значение искомого символа. Комбинация \xhhh состоит из из обратной дробной черты, за которой следует x, а за ним, в свою очередь, следует последовательность шестнадцатеричных цифр. Считается, что она задает значение искомого символа. Нет ограничения на длину этой последовательности шестнадцатеричных цифр. Последовательность восьмеричных или шестнадцатеричных цифр оканчивается, когда встречается первый символ, который не есть восьмеричная или шестнадцатеричная цифра соответственно. Если значение символьной константы превосходит максимальное из char, то оно определяется реализацией.

Константы с плавающей точкой состоят из целой части, символа точка, дробной части, e или E, целого показателя с возможным знаком и возможным окончанием, указывающим тип. Целая и дробная части состоят из последовательности десятичных (основание счисления десять) цифр. Или целая часть, или дробная часть (но не обе) могут отсутствовать. Или точка, или символ e (или E) вместе с показателем могут отсутствовать (но не оба). Тип константы с плавающей точкой есть double, если только он не задан явно с помощью окончания. Окончания f или F задают тип float, окончания l или L задают тип long double.

Строка литералов есть последовательность символов (как они определены в $$R.2.5.2), заключенная в двойные кавычки, т.е. "...". Строка имеет тип "массив символов" и класс памяти static ($$R.3.5), она инициализируется заданными символами. Будут ли все строки различны (т.е. хранится в отдельных объектах), определяется реализацией.

строка будет содержать два символа '\xA' и 'B' (а не один шестнадцатеричный символ '\xAB').

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

Описание ($$r.7) делает известным в программе одно или несколько имен. Описание считается определением, если только оно не описывает функцию без задания ее тела ($$R.8.3), не содержит описателя extern ($$R.7.11), не имеет части инициализации или тела функции, не является описанием статического члена данных в описании класса ($$R.9.4), не является описанием имени класса ($$R.9.1), не является описанием typedef ($$R.7.1.3). Ниже приведены примеры определений:

тогда как ниже следуют только описания:

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

Здесь второе x инициализируется своим собственным (неопределенным) значением.

Здесь элемент перечисления x опять инициализируется своим собственным (неопределенным) значением.

Программа состоит из одного или нескольких файлов, связываемых вместе ($$R.2). Файл состоит из последовательности описаний.

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

или

В последнем определении argc задает число параметров, передаваемых программе окружением, в котором она выполняется. Если argc не равно нулю, параметры должны передаваться как строки, завершающиеся символом '\0', с помощью argv[0] до argv[argc-1], причем argv[0] должно быть именем, под которым программа была запущена, или "". Должно гарантироваться, что argv[argc]==0.

описанной в <stdlib.h>, завершает программу. Значение параметра передается окружению программы в качестве результата программы.

описанной в <stdlib.h>, завершает программу без выполнения деструкторов статических объектов и без вызова функций, заданных в atexit().

Существует два описываемых класса памяти: автоматический и статический.

Существуют два вида типов: основные и производные.

Существует несколько основных типов. В стандартном заголовочном файле <limits.h> задаются в зависимости от реализации минимальные и максимальные значения каждого типа.

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

Основные и производные типы можно поименовать с помощью механизма typedef ($$R.7.1.3), а семейство типов и функций можно задать и поименовать с помощью механизма шаблона типов ($$R.14).

Любой объект - это некоторая область памяти, адрес - выражение, ссылающееся на объект или функцию. Очевидным примером адреса будет имя объекта. Существуют операции, порождающие адреса, например, если E выражение типа указатель, то *E - адресное выражение, соответствующее объекту, на который указывает E. Термин "адрес" ("lvalue" т.е. left value - левая величина) появляется из оператора присваивания E1 = E2, где левый операнд E1 должен "адресовать" изменяемую переменную. При обсуждении всех операций в $$R.5 указывается применимы ли они к адресным операндам и порождают ли они сами адреса. Адрес может изменяться, если он не является именем функции, именем массива или const.

Некоторые операции в зависимости от своих операндов могут вызвать преобразование значения операнда от одного типа к другому. Здесь описываются преобразования, вызванные самыми обычными операциями, и объясняется каковы могут быть результаты таких преобразований. По мере надобности будут даны дополнительные объяснения при обсуждении каждой операции. Подобные преобразования также происходят при инициализации ($$R.8.4, $$R.8.4.3, $$R.12.8, $$R.12.1). В $$R.12.3 и $$R.13.2 описываются преобразования, заданные пользователем, и их соотношения со стандартными преобразованиями. В результате преобразования может получиться адрес, только если результат есть ссылка ($$R.8.2.2).

Всюду, где требуется целое, можно использовать char, short int, элемент перечисления ($$R.7.2) или битовое поле ($$R.9.6), причем в знаковом и беззнаковом вариантах. Если int может представлять все значения исходного типа, значение преобразуется к int, иначе оно преобразуется к unsigned int. Это называется стандартным преобразованием для целочисленных.

Если целое преобразуется в беззнаковый тип, то полученное значение есть наименьшее беззнаковое целое, совпадающее с целым со знаком по (mod 2**n), где n есть число битов в представлении беззнакового целого. Для представления в дополнительном коде это преобразование лишь концептуальное, никаких изменений в двоичном представлении в действительности не происходит.\

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

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

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

Всюду, где указатели ($$R.8.2.1) присваиваются, инициализируются, сравниваются или используются иным образом, могут происходить следующие преобразования:

Всюду, где ссылки ($$R.8.2.2) инициализируются (включая передачу параметров ($$R.5.2.2) и возврат значения функции ($$R.6.6.3)) или используются иным образом, возможны следующие преобразования:

Всюду, где указатели на члены ($$R.8.2.3) инициализируются, присваиваются, сравниваются или используются иным образом, могут происходить следующие преобразования:

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

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

Понятие уточняющее-имя-класса, за которым следует :: и имя члена этого класса ($$R.9.2), или члена базового по отношению к данному класса ($$R.10) является уточненное-имя. Его тип есть тип члена, а результат выражения есть этот член. Результат является адресом, если таковым является член. Имя класса может быть скрыто другим именем (не типа), в таком случае все равно имя класса доступно и его можно использовать. Если используется имя-класса::имя-класса или имя-класса::~имя-класса, оба понятия имя-класса должны обозначать один и тот же класс. С помощью такой записи обозначаются конструкторы ($$R.12.1) и деструкторы ($$R.12.4) соответственно. Можно использовать уточняющие имена неоднократно, например, N1::N2::N3::n, чтобы обозначать вложенные типы ($$R.9.7).

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

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

Конструкция имя-простого-типа ($$R.7.1.6), за которой следует список-выражений в скобках образует значение указанного типа с учетом списка выражений. Если список выражений содержит более одного значения, тип должен быть классом с конструктором, описанным соответствующим образом ($$R.8.4, $$R.12.1).

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

Значение, получаемое в результате применения постфиксной операции ++, есть значение операнда. Операнд должен быть изменяемым адресом. Тип операнда должен быть арифметический или тип указателя. После выборки результата (для дальнейшего использования) объект увеличивается на 1. Тип результата совпадает с типом операнда, но не является адресом (см. так же $$R.5.7 и $$R.5.17).

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

Унарная операция * означает косвенность: выражение должно быть указателем, а результат является адресом, ссылающимся на объект, на который указывает выражение. Если тип выражения есть "указатель на T", то тип результата будет "T".

Операнд префиксной операции ++ увеличивается на 1. Операнд должен быть изменяемым адресом. Тип операнда должен быть арифметическим или указателем. Результатом является новое значение операнда, оно считается адресом. Выражение ++x эквивалентно x+=1. Для уточнения преобразований можно обратиться к описанию сложения ($$R.5.7) и операций присваивания ($$R.5.17).

Операция sizeof вычисляет размер своего операнда в байтах. Операнд должен быть или выражением, которое не вычисляется, или именем типа в скобках. Операцию sizeof нельзя применять к функции, битовому полю, неопределенному классу, типу void или к массиву с неуказанными границами индексов. Байт никак не определяется языком, кроме как результата операции sizeof, именно sizeof(char) есть 1.

Операция new предназначена для создания объекта типа имя-типа ($$R.8.1). Этот тип должен быть типом объекта и функции нельзя размещать с ее помощью, хотя указатели на функции можно.

Время жизни объекта, созданного с помощью new, не ограничивается областью видимости, в которой он был создан. Операция new возвращает указатель на созданный объект. Если объект является массивом, возвращается указатель на начальный элемент массива. Например, обе операции new int и new int[1] возвратят int* , а типом new int[i][10] будет int(*)[10]. Если описывается тип массива ($$R.8.2.4), все размерности, кроме первой, должны быть выражениями- константами ($$R.5.19) с положительным значением. Первая размерность массива может задаваться произвольным выражением, даже если используется имя-типа (здесь нарушается общее требование, чтобы размерности массива в конструкции имя-типа были выражениями-константами ($$R.5.19)).

может привести к ошибке, т.к. операции применяются в таком порядке

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

размещает массив из 10 указателей на функции (не имеющие параметров и возвращающие int).

Символ * используется в описателе указателя, а не в качестве операции умножения.

Операция delete уничтожает объект, созданный с помощью new.

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

Здесь выражение должно указывать на массив. Если есть деструкторы, они будут вызываться для удаления указанных объектов.

Явное преобразование типа можно задать с помощью функциональной записи ($$R.5.2.3) или с помощью операции приведения.

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

Операции указатель-на-член применяются слева направо.

приводит к вызову функции-члена, обозначенной ptr_to_mfct, для объекта, на который настроен указатель ptr_to_obj. Результат операции .* или ->* является адресом, если второй операнд есть адрес.

Мультипликативные операции *, /, и % выполняются слева направо.

Операнды операций * и / должны иметь арифметический тип, операнды для % должны быть целочисленного типа. Обычные арифметические преобразования ($$R.4.5) производятся над операндами и определяют тип результата.

Аддитивные операции + и - выполняются слева направо, при этом происходят обычные арифметические преобразования ($$R.4.5) операндов арифметического типа.

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

Операции сдвигов << и >> выполняются слева направо.

Операнды должны быть целочисленного типа, и над ними производятся стандартные целочисленные преобразования. Тип результата совпадает с типом преобразованного левого операнда. Результат не определен, если правый операнд отрицателен или больше или равен числу разрядов в двоичном представлении преобразованного левого операнда. Значением выражения E1<<E2 будет E1 (рассматриваемое как набор разрядов), сдвинутое влево на E2 разрядов, причем освободившиеся разряды заполняются нулями. Значением выражения E1>>E2 будет E1, сдвинутое вправо на E2 разрядов. Если E1 беззнакового типа или имеет неотрицательное значение, гарантируется, что сдвиг вправо - логический (заполнение нулями), иначе результат зависит от реализации.

Операции отношения выполняются слева направо, но этот факт мало что дает, ибо выражение a<b<c означает (a<b)<c, а вовсе не (a<b)&&(b<c).

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

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

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

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

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

Операции && выполняются слева направо. Такая операция дает результат 1, если оба операнда ее отличны от нуля, иначе результат - 0. В отличие от & при операции && гарантируется вычисление слева направо, более того, второй операнд не вычисляется, если первый операнд равен 0.

Операции || выполняются слева направо. Результат операции 1, если один из ее операндов отличен от нуля, иначе результат - 0. В отличие от | при операции || гарантируется вычисление слева направо, более того, второй операнд не вычисляется, если значение первого операнда отлично от нуля.

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

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

При простом присваивании (=) значение выражения заменяет собой значение объекта, с которым сопоставляется левый операнд. Если оба операнда арифметического типа, правый операнд, прежде чем произойдет присваивание, преобразуется к типу левого операнда. Неявные преобразования к типу перечисления ($$R.7.2) не производятся, поэтому если левый операнд имеет тип перечисления, правый операнд должен быть таким же. Если левый операнд имеет тип указателя, правый операнд должен быть типа указателя или выражением-константой, дающим результат 0. Правый операнд преобразуется к типу левого операнда, прежде выполнения присваивания.

Операции запятая выполняются слева направо.

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

содержит три параметра, причем второй имеет значение 5.

В нескольких местах описания С++ требуются выражения, которые дают в результате целочисленную константу, например: в задании границ массива ($$R.8.2.4), в выражениях case ($$R.6.4.2), для задания длины битового поля ($$R.9.6) и как инициализирующее значение элемента перечисления ($$R.7.2).

В конструкции выражение-константа могут участвовать: литералы ($$R.2.5), элементы перечисления, значения целочисленного типа со спецификацией const, инициализированные выражением-константой ($$R.8.4) и выражения sizeof. Константы с плавающей точкой ($$R.2.5.3) должны быть приведены к целочисленному типу. Допустимы только преобразования типа к целочисленному типу. В частности не допустимы функции, объекты классов, указатели и ссылки, если не считать их использования в sizeof. Операция запятая и операция присваивания не допустимы в выражении-константе.

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

Оператор можно снабдить меткой.

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

Чаще всего операторами бывают выражения; в этом случае оператор имеет такой вид:

Обычно операторы-выражения являются присваиваниями или вызовами функций. Все побочные эффекты выполнения оператора-выражения происходят до выполнения следующего оператора. Оператор-выражение с отсутствующим выражением называется пустым оператором. Он может пригодиться, если необходимо поставить метку перед самым концом составного оператора ({) или для задания пустого тела оператора цикла while ($$R.6.5.1).

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

Отметим, что описание считается оператором ($$R.6.7).

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

Оператор в выбирающем-операторе не может быть описанием.

Выражение должно быть арифметического типа, или типа указателя, или типа класс, для которого существует однозначное преобразование в арифметический тип или тип указателя ($$R.12.3).

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

Здесь выражение-константа ($$R.5.19) приводится к преобразованному типу выражения переключателя. Никакие две константы из case одного переключателя не должны иметь одинаковое значение.

Эти операторы задают виды цикла.

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

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

Оператор for

за исключением того факта, что оператор continue в операторе for вызовет выполнение выражение-2 перед тем& как начать повторное вычисление выражения-1. Таким образом, первый оператор задает инициализацию для цикла, первое выражение производит проверку, выполняемую перед каждым шагом цикла, так что цикл завершается, когда выражение становится нулем, а второе выражение обычно задает приращение, и оно добавляется после каждого шага цикла. Первое выражение должно иметь арифметический тип, или тип указателя, или тип класса, для которого существует однозначное преобразование к арифметическому типу или типу указателя ($$R.12.3).

Операторы перехода делают безусловную передачу управления.

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

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

оператор continue, не относящийся ко внешним операторам цикла, эквивалентен оператору goto contin.

Возврат из функции в обратившуюся к ней функцию происходит с помощью оператора return.

Оператор goto безусловно передает управление на оператор, помеченный идентификатором. Идентификатор должен быть меткой ($$R.6.1), находящейся в текущей функции.

Оператор описания заводит в блоке новый идентификатор и имеет вид:

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

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

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

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

Описатели в списке-описателей ($$R.8) содержат описываемые идентификаторы. Конструкция спецификации-описания может отсутствовать только в определении функций ($$R.8.3) или в описании функций. Список-описателей может быть пустым, только при описании класса ($$R.9) или перечисления ($$R.7.2), т.е. когда спецификация-описания есть спецификация-класса или спецификация-перечисления. Конструкция описание-asm объясняется в $$R.7.3, а спецификация-связи в $$R.7.4. Описание происходит в определенной области видимости ($$R.3.2), правила области видимости приводятся в $$R.10.4.

В описании можно использовать следующие спецификации:

Здесь описание static Pc является незаконным, поскольку не указано никакого имени статической переменной типа Pc. Чтобы иметь переменную типа int с именем Pc, необходимо задать спецификацию-типа int, чтобы показать, что (пере)определяется имя Pc из typedef, а не просто Pc является одним из элементов последовательности конструкций спецификация-описания, например,

Спецификации класса памяти могут быть такие:

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

Описания со спецификацией typedef задают идентификаторы, которые позднее могут использоваться для обозначения основных или производных типов. Спецификация typedef недопустима в определении-функции ($$R.8.3).

конструкции

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

Спецификация шаблона типа используется для задания семейства типов или функций (см. $$R.14).

Спецификация friend используется для задания доступа к членам класса (см. $$R.11.4).

К спецификации типа относятся:

При описании объекта служебные слова const и volatile можно добавить к любой законной спецификации-типа. Во всех других случаях в описании может присутствовать не более одной спецификации-типа. Объект со спецификацией const можно инициализировать, но его значение не должно изменяться в дальнейшем. Объект со спецификацией const, если только он не был явно описан как extern, не подлежит внешнему связыванию и должен инициализироваться ($$R.8.4, $$R.12.1). Целое со спецификацией const, инициализированное выражением-константой, может использоваться в выражении-константе ($$R.5.19). Каждый элемент массива со спецификацией const имеет ту же спецификацию, а каждый нестатический член, не являющийся функцией, из объекта класса со спецификацией const сам считается const ($$R.9.3.1). Объект типа без конструктора или деструктора, который имеет спецификацию const, может быть помещен в память, доступную только по чтению. Попытка записи в любую часть такого объекта или приведет к особой адресной ситуации, или пройдет бесследно, как если бы объект не имел спецификации const.

Вместе с int нельзя задавать более одного служебного слова long или short. Они могут использоваться и поодиночке, тогда считается, что тип есть int. Служебное слово long может появиться вместе с double. Вместе с char, short, int или long нельзя задавать более одного служебного слова signed или unsigned. Они могут использоваться и поодиночке, тогда считается, что тип есть int. Спецификация signed указывает, что объекты типа char и битовые поля являются знаковыми, для других целочисленных типов эта спецификация избыточна.

Имя, уточненное именем-класса должно быть типом, определенным в этом классе или в базовом классе этого класса. Как обычно, имя, описанное в производном классе, делает невидимыми члены с этим именем из базовых классов (см. $$R.3.2).

Перечисление является отдельным целочисленным типом ($$R.3.6.1) с константами-именами. Его имя в своей области видимости становится конструкцией имя-перечисления, т.е. служит зарезервированным словом.

значения a, c, и d заданы как 0, b и e как 1, а f как 3.

color задан как целочисленный тип, описывающий разные цвета, col описан как объект этого типа, а cp как указатель на объект этого типа. Возможными значениями объекта типа color являются red, yellow, green, blue. Эти значения можно преобразовать в целые значения 0, 1, 20 и 21. Поскольку каждое перечисление - это отдельный тип, объекту типа color можно присваивать только значения типа color, например,

Обратитесь также к $$R.18.3.

Описание asm имеет вид:

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

С помощью спецификации-связи можно связать ($$R.3.3) фрагменты программ на С++ и на другом языке:

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

Когда задается спецификация связи, то функции и объекты можно описать как статические внутри { }. Для таких функций или объектов команда связывания игнорируется. Иначе, функция, описанная при задании связи, трактуется, как если бы она была явно описана как extern, например, ниже второе описание ошибочно ($$R.7.1.1):

Объект, описанный внутри конструкции

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

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

Описание состоит из двух частей: спецификации (спецификация-описания; см. $$R.7.1) и описателей (список-описателей). Спецификации задают основной тип, класс памяти или другие свойства описываемых объектов и функций. Описатели задают имя этих объектов и функций, а также, возможно, изменяют тип с помощью таких операций, как * (указатель на) и () (функция возвращающая). В описателе также можно задать начальные значения, инициализация обсуждается в $$R.8.4 и $$R.12.6.

Конструкция имя-класса имеет определенное назначение при описании класса с этим именем, она же используется как уточнение в операции :: для разрешения коллизий в области видимости ($$R.12.1, $$R.12.4).

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

абстрактный-описатель opt ( список-описаний-параметров ) список-спецификаций cv opt

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

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

Неоднозначность, отмеченная в $$R.6.8, которая возникает из-за сходства между приведением, заданным в функциональном стиле, и описанием, может также появиться в контексте описания. В этом контексте она проявляется как сходство между описанием функции, в котором есть избыточные скобки вокруг имени параметра, и описанием объекта, в котором в качестве инициализатора используется операция приведения, заданная в функциональном стиле. Как и для операторов, неоднозначность устраняется правилом, согласно которому следует считать описанием любую конструкцию, которая может служить таковым. Можно явно устранить неоднозначность в описании или с помощью приведения, заданного не в функциональном стиле, или с помощью операции = для обозначения инициализации, например,

Список описателей следует после (возможно пустого) списка спецификаций-описания ($$R.7.1). Каждый описатель содержит в точности одно имя-из-описателя, которое задает описываемый идентификатор. Если не считать описаний некоторых специальных функций ($$R.12.3, $$R.13.4), имя-из-описателя является просто идентификатором. Спецификации auto, static, extern, register, friend, inline, virtual или typedef относятся непосредственно к каждому имени-из-описателя из списка описателей. Тип каждого имени-из-описателя определяется как спецификацией-описания ($$R.7.1), так и его описателем.

где T обозначает тип, а D - описатель. Если в описании D есть идентификатор без скобок, то тип этого идентификатора есть T.

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

В описании T D, в котором D имеет вид

тип описываемого идентификатора есть "... список-спецификаций-cv указатель на T". Конструкция список-спецификаций-cv относится к указателю, а не к указуемому объекту.

определяются: ci как константа целое; pc как указатель на константу целое; cpc как константа указатель на константу целое; i как целое; p как указатель на целое; и cp как константа указатель на целое. После инициализации значения ci, cpc и cp не могут быть изменены. Значение pc можно изменять так же, как и значение объекта, на который указывает cp. Приведем примеры допустимых операций:

Недопустимы следующие операции:

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

В описании T D, в котором D имеет вид

тип описываемого идентификатора есть "...список-спецификаций-cv ссылка на T". Тип void& недопустим.

a описывается как параметр, являющийся ссылкой, поэтому вызов f(d) приведет к увеличению d на 3.14. Во фрагменте

описывается: функция g() возвращает ссылку на целое; поэтому оператор g() = 7; присвоит 7 четвертому элементу массива v. Рассмотрим следующий программный фрагмент:

Здесь p описано как ссылка на указатель на link, поэтому вызов h(q) не изменит значение q, равное 0, см. также $$R.8.4.3.

В описании T D, в котором D имеет вид

pmi и pmf описываются как указатель на член X типа T и указатель на член X типа void(int) соответственно. Эти объекты можно использовать так:

В описании T D, в котором D имеет вид

описывается идентификатор типа " ... массив T". Если выражение-константа присутствует ($$R.5.19), то оно должно иметь целочисленный тип и значение, большее 0. Это выражение задает число элементов массива. Если значение выражения-константы есть N, то массив имеет N элементов с индексами от 0 до N-1.

описаны массив чисел типа float и массив указателей на числа типа float, а в описании

описан статический трехмерный массив целых размера 3x5x7. Строго говоря, x3d является массивом из трех элементов, каждый из которых есть массив из пяти массивов, а каждый из последних является массивом из семи целых. В выражении допустимо появление любого из следующих выражений: x3d, x3d[i], x3d[i][j], x3d[i][j][k].

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

В описании T D, в котором D имеет вид

описываемый идентификатор имеет тип "...список-спецификаций-cv функция с параметрами типа список-описаний-параметров возвращающая T".

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

Конструкция описатель из определения-функции должна содержать описатель вида

в соответствии с определениями из $$R.8.2.5

Здесь int представляет спецификации-описания, max(int a, int b, int c) - описатель, а { /* ... */ } - тело-функции.

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

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

задает не объект a типа класс X, а является описанием функции без параметров, возвращающей X.

Агрегатом называется массив или объект типа класс ($$R.9), не имеющий конструкторов ($$R.12.1), частных или защищенных членов ($$R.11), базовых классов ($$R.10) и виртуальных функций ($$R.10.2). Если агрегат инициализируется, то инициализатором должен быть список-инициализаторов, который состоит из заключенного в фигурные скобки списка, разделенного запятыми, инициализаторов для членов агрегата. Инициализаторы идут в возрастающем порядке индексов или членов агрегата. Если агрегат содержит вложенные агрегаты, это правило применяется рекурсивно для членов вложенных агрегатов. Если инициализаторов в списке меньше, чем членов агрегата, то он дополняется нулевыми значениями соответствующих типов.

ss.a инициализируется значением 1, ss.b - "asdf", а ss.c - 0.

массив x инициализируется как одномерный массив из трех элементов, поскольку размер массива не указан, и приведено три инициализатора.

Здесь значения 1, 3, 5 инициализируют первую строку массива y[0], т.е. y[0][0], y[0][1] и y[0][2]. Аналогично, следующие две строки инициализируют y[1] и y[2]. Инициализаторы приведены не полностью, поэтому y[3] инициализируется нулями. Точно такого же результата можно достичь с помощью такой инициализации:

Последний (самый правый) индекс изменяется быстрее всего.

инициализируется первый столбец y (который рассматривается как двумерный массив), а остальные столбцы принимают значение 0.

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

Заметим, что поскольку '\n' задает один символ, и поскольку добавляется завершающий символ '\0', sizeof(msg) равно 25.

Переменная, описанная как T&, т.е. "ссылка на тип T" ($$R.8.2.2), должна инициализироваться объектом типа T или объектом, который можно преобразовать к типу T, например,

Класс есть тип. Его имя используется как имя-класса ($$R.9.1), т.е. становится зарезервированным словом в его области видимости.

Для образования конструкции имя-класса используются спецификации-класса и спецификации-сложного-типа ($$R.7.1.6). Объект класса состоит из последовательности (возможно пустой) членов.

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

Отсюда следует, что такие присваивания приводят к несоответствию типов:

Ниже описывается перегрузка ($$R.13) функции f(), а не просто повторное описание той же функции:

По той же причине нельзя дважды определять класс, это видно из примера ниже, где дважды определен S:

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

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

Описание friend (дружественные функции) обсуждается в $$R.11.4, а функция operator в $$R.13.4. Если класс, указанный как друг, пока еще не описан, его имя считается принадлежащим той же области видимости, в которой находится имя класса, содержащего описание friend ($$R.11.4).

A в начале задается, как имя класса, а затем оно переопределяется как имя указателя на объект этого класса, поэтому для обозначения этого класса следует использовать спецификацию-сложного типа class A. Такое "трюкачество" с именами может вызвать недоумение, и лучше его избегать.

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

задает s как объект типа tnode и sp как указатель на tnode. С учетом этих описаний s->count обозначает член count структуры, на которую указывает sp; s.left обозначает указатель left на поддерево структуры s; s.right->tword[0] обозначает первый символ члена tword поддерева структуры s, на которую указывает right.

Функция, описанная как член (без спецификации friend $$R.11.4), называется функция-член и вызывается в соответствии с синтаксисом члена класса ($$R.5.2.4), например:

Здесь set является функцией-членом и может вызываться так:

Обозначение tnode::set указывает, что функция set является членом и находится в области видимости класса tnode. Имена членов tword, count, left и right относятся к членам того объекта, с именем которого вызывалась Поэтому в вызове n1.set("abc",&n2,0) tword обозначает n1.tword, а в вызове n2.set("def",0,0) tword обозначает n2.tword. Функции strlen, error и strcpy должны быть описаны где-то в программе.

В нестатической ($$R.9.3) функции-члене служебное слово this обозначает указатель на объект, с которым эта функция вызывалась. В функции-члене класса X тип this есть X *const, если только функция-член не описана со спецификацией const или volatile; для этих случаев this имеет тип const X *const или volatile X *const соответственно. Если функция описана с указанием const и volatile, то тип this будет const volatile X *const, см. также $$R.18.3.3. Приведем пример:

Операция a++ в теле функции s::h ошибочна, поскольку с ее помощью делается попытка изменить объект (часть его), с которым вызывалась функция s::h(). Это недопустимо для функции-члена, описанной со спецификацией const, т.к. this является указателем на const, иными словами, *this имеет спецификацию const.

Здесь вызов y.g() является ошибкой, т.к. y есть const, а s::g() - функция-член без спецификации const, которая может изменять (и изменяет) объекты, для которых она вызывалась.

Функцию-член можно определить ($$R.8.3) в описании класса, в таком случае она считается подстановкой (inline, $$R.7.1.2). Определять функцию в описании класса - это эквивалентно тому, чтобы описывать функцию и определять ее со спецификацией inline сразу же после описания класса. Считается, что такой перенос определения функции происходит после препроцессорной обработки до стадии синтаксического анализа и контроля типов. Поэтому программный фрагмент

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

Здесь в функции x::f() используется x::b, а не глобальное b.

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

Здесь к функции reshedule можно обратиться без указания объекта класса process таким образом:

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

Объединение можно представить как структуру, все члены имеют нулевое смещения, а размер ее достаточно велик, чтобы вмещать любой из ее членов. В любой момент времени объединение может содержать только один член. В объединении могут быть функции-члены (в том числе конструкторы и деструкторы), но не виртуальные функции ($$R.10.2). Объединение не может иметь базовых классов и не может само использоваться в качестве базового класса. Членом объединения не может быть объект класса с конструктором или деструктором, а также с определенной пользователем операцией присваивания ($$R.13.4.3). Объединение не может содержать статических членов, представляющих данные.

называется безымянным объединением, оно определяет объект без имени (и без типа). Имена всех членов безымянного объединения должны отличаться от других имен в той области видимости, в которой описано объединение; их можно использовать в этой области видимости непосредственно, без обычных операций доступа к членам ($$R.5.2.4). Приведем пример:

Здесь a и p используются как обычные переменные (не члены), но поскольку они входят в одно объединение, их адреса совпадают.

Здесь присваивание простому имени aa незаконно, т.к. имя члена не привязано ни к какому объекту.

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

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

Функции-члены вложенного класса не имеют особых прав доступа к членам объемлющего класса, они подчиняются обычным правилам доступа ($$R.11). Аналогично, функции-члены объемлющего класса не имеют особых прав доступа к членам вложенного класса и подчиняются обычным правилам доступа, например:

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

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

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

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

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

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

Конструкция имя-класса в спецификации-базовых должна обозначать ранее описанный класс ($$R.9), который называется базовым по отношению к определяемому классу. Говорят, что класс является производным от своих базовых классов. Назначение конструкции спецификация-доступа объясняется в $$R.11. К членам базового класса, если только они не переопределены в производном классе, можно обращаться так, как будто они являются членами производного класса. Говорят, что производный класс наследует члены базового класса. С помощью операции разрешения области видимости :: ($$R.5.1) к члену базового класса можно обращаться явно. Такое обращение возможно и в том случае, когда имя члена базового класса переопределено в производном классе. Производный класс сам может выступать как базовый при контроле доступа, см. $$R.11.2. Указатель на производный класс может неявно преобразовываться в указатель на однозначно определенный и доступный базовый класс ($$R.4.6). Ссылка на производный класс может неявно преобразовываться в ссылку на однозначно определенный и доступный базовый класс ($$R.4.7).

Здесь присваиваются значения четырем членам d, а bp настраивается на d.

Здесь дважды вызывается A::f(), поскольку это единственная функция f() в классе B.

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

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

Здесь объект класса C будет иметь два вложенных объекта класса L.

Здесь объект класса C будет иметь только один вложенный объект класса V.

Здесь объект класса AA будет иметь два вложенных объекта класса B: из класса Z и виртуальный, разделяемый между классами X и Y.

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

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

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

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

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

Если класс base содержит виртуальную ($$R.7.1.2) функцию vf, а производный от него класс derived также содержит функцию vf того же типа, тогда вызов vf для объекта класса derived является обращением к derived::vf, даже если доступ к этой функции происходит через указатель или ссылку на класс base. Говорят, что функция производного класса подавляет функцию базового класса. Однако, если типы функций ($$R.8.2.5) различны, функции считаются разными и механизм виртуальности не действует (см. также $$R.13.1). Считается ошибкой, если функция производного класса отличается от виртуальной функции базового класса только типом возвращаемого значения. Рассмотрим пример:

Здесь три вызова для объекта d класса derived приведут к обращениям к derived::vf1, base::vf2 и base::f соответственно. Иными словами, интерпретация вызова виртуальной функции зависит от типа объекта, для которого она вызывается, тогда как интерпретация вызова невиртуальной функции-члена зависит только от типа указателя или ссылки на этот объект. Например, выражение bp->vf1() приведет к вызову derived::vf1(), поскольку bp указывает на объект класса derived, в котором функция derived::vf1() подавляет виртуальную функцию base::vf1().

Здесь обращение к f из D приводит к вызову B::f, а не D::f.

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

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

Поскольку функция shape::draw() является чистой виртуальной функцией, то такой же будет по определению и функция ab_circle::draw(). Для приведенного ниже описания класс circle не будет абстрактным, и у функции circle::draw() где-то должно существовать определение.

Теперь можно свести воедино правила областей видимости для программы на С++. Эти правила одинаково применимы для всех имен (включая имя-typedef ($$R.7.1.3) и имя-класса ($$R.9.1)) и в любом контексте, для которого они допустимы по синтаксису языка. Здесь рассматриваются только области видимости на лексическом уровне, вопросы связывания обсуждаются в $$R.3.3. Понятие момента описания было введено в $$R.3.2.

Член класса может быть:

Описания членов могут быть снабжены спецификацией доступа ($$R.10):

Допустимо любое число спецификаций доступа и задавать их можно в любом порядке, например,

Если класс описан как базовый ($$r.10) по отношению к другому классу с помощью спецификации доступа public, то члены со спецификацией public или protected из базового класса являются соответственно членами с той же спецификацией для производного класса. Если класс описан как базовый по отношению к другому с помощью спецификации доступа private, то члены со спецификацией public или protected из базового класса являются членами со спецификацией private для производного класса. Частные члены базового класса остаются недоступными даже для производных классов, если только для обеспечения доступа при описании базового класса не было использовано описание friend.

Здесь класс является общим (public) базовым классом для D2, D4 и D6 и частным (private) базовым классом для D1, D2 и D5.

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

Во внешней функции ef можно использовать только имена c, e, и df. Поскольку функция df член класса D, в ней можно использовать имена b, c, bf, d, e и df, но не a. Функция bf - член класса B и в ней можно использовать члены a, b, c и bf.

Описание доступа для имени перегруженной функции устанавливает доступ в базовом классе ко всем функциям с этим именем, например:

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

Можно объявить все функции класса X друзьями класса Y с помощью спецификации-сложного-типа ($$R.9.1):

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

Друг или функция-член производного класса имеет доступ к защищенному статическому члену базового класса. Друг или функция-член производного класса могут получить доступ к защищенному нестатическому члену одного из своих базовых классов только через указатель, ссылку или объект производного класса (или любого класса, являющегося производным по отношению к нему). Рассмотрим пример:

Правила доступа ($$r.11) к виртуальной функции определяются ее описанием и на них не влияют правила доступа к к функции, которая позднее будет подавлять ее. Приведем пример:

Права доступа проверяются при самом вызове, используя тип выражения, обозначающее объект, для которого вызывается функция-член (в примере выше это B*). Доступ к функции-члену в классе, где она определена (D в примере выше), в общем случае неизвестен.

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

Поскольку W::f() доступно в C::f() по пути, связанному с общим наследованием из B, обращение является законным.

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

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

Объект, созданный таким образом является безымянным (если только конструктор не использовался для инициализации поименованной переменной как zz выше), а время его жизни ограничено выражением, в котором он был создан, см. $$R.12.2.

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

Здесь нужен временный объект для построения X(2), прежде чем передать его функции f() с помощью X(X&). Альтернативное решение, - построить объект X(2) в памяти, используемой для хранения параметра при первом вызове f(). Помимо этого, временный объект может понадобиться для хранения результата f(X(2)) прежде, чем копировать его в объект b с помощью X(X&), и здесь возможно альтернативное решение: хранить результат f(X(2)) в памяти для объекта b. С другой стороны, существует много функций f(), для которых выполнение выражения a=f(a) требует временного объекта или для параметра a, или для результата f(a), чтобы избежать нежелательного использования памяти, которой приписывается имя a.

Преобразования объектов класса можно задать с помощью конструкторов или функций преобразования.

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

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

Функция-член класса X, имя которой имеет вид,

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

Здесь во всех трех операторах присваиваемое значение будет преобразовываться с помощью функции X::operator int(). Пользовательские преобразования не ограничиваются только использованием в присваивании и инициализации, например:

Деструктором называется функция-член класса cl с именем ~cl, она используется для уничтожения значений типа cl непосредственно перед уничтожением объекта, содержащего их. Деструктор не имеет формальных параметров и для него нельзя задать тип возвращаемого значения (даже void). Нельзя применять операцию взятия адреса для деструктора. Можно вызывать деструктор для объектов со спецификацией const или volatile, но сам деструктор нельзя описывать с этими спецификациями ($$R.9.3.1). Деструктор не может быть и статическим.

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

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

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

В каждом классе можно описать только одну функцию operator delete(), значит эта функция не может быть перегруженной. Глобальная функция operator delete() имеет единственный параметр типа void*.

В этом примере память для объекта класса D выделяется с помощью D::operator new(), а благодаря наличию виртуального деструктора, освобождается с помощью D::operator delete().

Объект класса без конструкторов, без частных или защищенных членов, без виртуальных функций и без базовых классов можно инициализировать с помощью списка инициализаторов ($$R.8.4.1). Объект класса с конструктором должен инициализироваться или иметь стандартный конструктор ($$R.12.1). Стандартный конструктор используется для объектов, которые не проходят явной инициализации.

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

Перегрузка операции присваивания = не оказывает влияние на инициализацию.

Инициализация, происходящая в выражении операции new ($$R.5.3.3) и при инициализации базовых классов и членов, эквивалентна инициализации вида

Здесь v[0] и v[3] инициализируются значением complex::complex(double), v[1] инициализируется complex::complex(double,double), а v[2], v[4] и v[5] инициализированы complex::complex().

В определении конструктора можно задать инициализацию прямых базовых классов и членов, не наследуемых из базовых классов. Это особенно полезно для тех объектов, констант и ссылок, для которых различаются семантики присваивания и инициализации. Конструкция инициализатор-ctor имеет вид

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

X::r инициализируется для каждого объекта класса X ссылкой на X::a.

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

Объекты класса могут копироваться двумя способами: либо присваиванием ($$R.5.17), либо инициализацией ($$R.12.1, $$R.8.4), которая может происходить при передаче параметров ($$R.5.2.2) или результата функции ($$R.6.6.3). Для класса X эти две операции концептуально реализуются как операция присваивания и конструктор копирования ($$R.12.1). В программе можно определить или одну из них, или обе. Если пользователь не определил их в программе, то они будут для всех членов класса X определяться соответственно как присваивание по членам и инициализация по членам.

и инициализация копированием объектов типа const класса X будет невозможна.

и присваивание копированием объектов класса X типа const будет невозможно. Стандартная операция присваивания возвращает ссылку на объект, который нужно было копировать.

Вызов a.f() приведет к вызову s::f() (как и должно быть для объекта класса s ($$R.10.2)), а вызов b.f() приведет к вызову ss::f() ( как и должно быть для объекта класса ss).

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

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

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

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

Два описания функций с одинаковыми именами относятся к одной и той же функции, если они находятся в одной области видимости и имеют идентичные типы параметров ($$R.13). Функция-член производного класса относится к иной области видимости, чем функция-член базового класса с тем же именем. Рассмотрим пример:

Здесь D::f(char*) скорее скрывает B::f(int), чем перегружает эту функцию.

Функция, описанная локально, находится в иной области видимости, чем функция с файловой областью видимости.

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

Последовательности тривиальных преобразований, которые отличаются только порядком преобразований, считаются совпадающими. Отметим, что для функций с формальным параметром типа T, const T, volatile T, T&, const T& и volatile T& допустим фактический параметр из одно и того же множества значений. При необходимости для разделения последовательностей преобразований используются спецификации const и volatile, как описано в правиле [1] ниже.

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

Здесь вызов f(1) неоднозначен. Несмотря на то, что для вызова f(y(long(1))) требуется на одно стандартное преобразование больше, чем для вызова f(x(1)), второй вызов не является предпочтительным.

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

Последняя инициализация ошибочна, не из-за неоднозначности, а потому, что не определено ни одной функции f() типа int(...).

Перегружать можно большинство операций.

Две последние операции - это вызов функции ($$R.5.2.2) и индексация ($$R.5.2.1).

а также и специальные символы препроцессора # и ## ($$R.16).

Префиксную унарную операцию можно задать с помощью нестатической функции-члена ($$R.9.3), без параметров или с помощью функции, не являющейся членом, с одним параметром. Таким образом, для всякой префиксной унарной операции @, выражение @x может интерпретироваться как x.operator@() или как operator@(x). Если описаны функции-операторы обоих видов, то какая из них будет использоваться при вызове, определяется правилами сопоставления параметров ($$R.13.2). Постфиксные унарные операции, такие как ++ и -- , объясняются в $$R.13.4.7.

Бинарную операцию можно задать с помощью нестатической функции-члена ($$R.9.3), имеющей один параметр, или с помощью функции, не являющейся членом, с двумя параметрами. Таким образом, для всякой бинарной операции @ выражение x@y может интерпретироваться как x.operator@(y) или как operator@(x,y). Если описаны функции-операторы обоих видов, то какая из них будет использоваться при вызове, определяется правилами сопоставления параметров ($$R.13.2).

Функция присваивания operator=() должна быть нестатической функцией-членом. Она не наследуется ($$R.12.8). Более того, если пользователь не определил для класса X функцию operator=, то используется стандартная функция operator=, которая определяется как присваивание по членам для класса X.

Вызов функции есть конструкция вида:

Индексация, определяемая как:

Доступ к члену класса определяется с помощью операции ->:

Функция с именем operator++ и с одним параметром задает для объектов некоторого класса операцию префиксного инкремента ++. Функция с именем operator++ и с двумя параметрами задает для объектов некоторого класса операцию постфиксного инкремента ++. Для постфиксной операции ++ второй параметр должен быть типа int, и, когда в выражении встречается операция постфиксного инкремента, функция operator++ вызывается со вторым параметром, равным нулю. Приведем пример:

Конструкция описание в описании-шаблона-типа должна содержать описание или определение функции или класса.

Шаблон типа для класса определяет как будут строиться классы, подобно тому, как описание класса определяет как будут строиться объекты этого класса. Шаблон типа для класса vector можно описать следующим образом:

Префикс template<class T> показывает, что описывается шаблон типа, и что в этом описании используется имя-типа T, иными словами, vector - это параметризованный тип с параметром T.

Две конструкции шаблонное-имя-класса обозначают один и тот же класс, если в них совпадают имена шаблонов типа и значения указанных параметров. Например, в следующих описаниях x и y одного типа, который отличен от типа z:

Ниже приведены описания, в которых одинаковый тип имеют x2 и x3. Он отличается от типов x1 и x4:

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

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

можно разрешить неопределенность для третьего вызова, поскольку теперь задана функция, которая после стандартного преобразования char в int, может сопоставиться с вызовом max(a,c).

Все параметры-шаблона-типа, приведенные в шаблоне типа для функции, должны быть параметрами-типа.

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

Здесь определение функции sort будет использоваться для той функции из семейства sort, которая сопоставляется при вызове с типом параметра vector<char*>. Для других типов vector будет создаваться соответствующее им определение функции по шаблону типа.

Здесь описание класса будет использоваться в качестве определения потока символов (stream<char>). Другие потоки будут управляться с помощью шаблонных функций, создаваемых по шаблону типа для функций.

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

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

Функция-друг для шаблона типа не является неявной шаблонной функцией, например:

Здесь функция next_time() становится другом всех классов task, а каждый класс task имеет в качестве друга функцию preempt() c соответствующими типами параметров. Функцию preempt() можно определить как шаблон типа.

Для каждого шаблонного класса или функции, создаваемых по шаблону типа, образуется своя копия статических переменных или членов. Рассмотрим пример:

Здесь в классе X<int> есть статический член типа int, а в классе X<char> есть статический член типа char*.

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

Конструкция проверяемый-блок является оператором ($$R.6), а выражение-запуска - унарным выражением типа void ($$R.5). Иногда выражение-запуска называют "точкой запуска", а про функцию, в которой встретилось выражение-запуска, говорят, что она "запускает особую ситуацию. Часть программы, которой передается управление из точки запуска называется обработчиком.

При запуске особой ситуации управление передается обработчику. Запуск сопровождается передачей объект, тип которого определяет, какой обработчик должен перехватить особую ситуацию. Так, выражение

может быть перехвачено некоторым обработчиком с типом char*:

а особая ситуация Overflow (переполнение):

может быть перехвачена обработчиком

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

Обработчик типа T, const T, T& или const& сопоставим с выражением-запуска, имеющим операнд типа E, если:

Здесь обработчик Overflow будет перехватывать ситуации типа Overflow, а обработчик Matherr будет перехватывать ситуации типа Matherr и всех типов, являющихся общими производными от Matherr, включая Underflow и Zerodivide.

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

Приведем пример:

Механизм управления особыми ситуациями использует для реакции на ошибки при самой обработке особых ситуаций функции:

terminate() и unexpected().

Иногда от предусмотренной обработки особых ситуаций приходится переходить к более грубым приемам, например:

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

Функция, которая была задана в предыдущем вызове set_terminate(), будет возвращаемым значением текущего вызова. Это помогает пользователю реализовать алгоритм восстановления стека. По умолчанию функция terminate() вызывает abort().

Если функция, имеющая спецификацию-особой-ситуации, запускает неуказанную особую ситуацию, то вызывается функция

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

Функция, которая была задана в предыдущем вызове set_unexpected(), будет возвращаемым значением текущего вызова. Это помогает пользователю реализовать алгоритм восстановления стека. По умолчанию unexpected() вызывает terminate(). Поскольку по умолчанию terminate() вызывает abort(), результатом будет непосредственное и точное обнаружение ошибки.

Реализация языка С++ включает препроцессор с возможностями макроподстановки, условной трансляции и включения указанных файлов.

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

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

Например, строка

преобразуется в

Команда вида

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

описание

после макроподстановки примет вид

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

Тогда макровызов

после подстановки примет вид

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

то макровызов

приведет к такому результату:

После конкатенации соседних строк ($$R.16.1) получим:

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

тогда макровызов

приведет к такому результату:

Тогда макровызов

даст в результате

а вовсе не

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

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

Она заставляет препроцессор "забыть" макроопределение с этим идентификатором. Если указанный идентификатор не является определенным в данный момент макроименем, то команда #undef игнорируется.

Управляющая строка вида:

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

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

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

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

или

Если эта операция применяется к идентификатору, который был определен с помощью команды #define, и если это определение не было отменено командой #undef, то результат равен 1, иначе результат равен 0. Сам идентификатор defined нельзя переопределить, нельзя и отменить его определение.

эквивалентна строке

а управляющая строка

эквивалентна строке

Для удобства написания программ, порождающих текст на С++, введена управляющая строка вида:

Она задает значение предопределенному макроимени __LINE__ ($$R.16.10), которое используется в диагностических сообщениях или при символической отладке; а именно: номер следующей строки входного текста считается равным заданной константе, которая должна быть десятичным целым числом. Если задано "имяфайла", то значение макроимени __FILE__ ($$R.16.10) становится равным имени указанного файла. Если оно не задано, __FILE__ не меняет своего значения.

Строка вида:

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

Строка вида:

заставляет реализацию вести себя некоторым определенным образом при условии что реализация "понимает" эту строку. Любая нераспознанная строка #pragma игнорируется.

Команда препроцессора вида

не оказывает никакого действия.

В процессе трансляции определенную информацию содержат следующие предопределенные макроимена.

Кроме того, считается определенным при трансляции программы на С++ макроимя __cplusplus. Перечисленные макроимена нельзя как переопределять, так и отменять их определения. Макроимена __LINE__ и __FILE__ можно определить с помощью команды #line ($$R.16.6). Определено ли макроимя __STDC, и если да, то каково его значение, зависит от реализации.

Это приложение не относится к справочному руководству языка и не является определением конструкций C++.

В описаниях: typedef ($$R.7.1.3), класса ($$R.9), перечисления ($$R.7.2), шаблона типа - ($$R.14) введены новые, зависящие от контекста, служебные слова, а именно:

Отметим, что имя-typedef, обозначающее класс, является в то же время конструкцией имя-класса ($$R.9.1).

Это приложение не относится к справочному руководству С++ и не является определением конструкций языка.

то sizeof(A) равно в С sizeof(int), тогда как в С++ оно равно sizeof(e) и не обязано быть равно sizeof(int).

В этом разделе перечисляются основные расширения языка С, введенные в С++.

Здесь перечисляются возможности, добавленные к С, версией языка С++ 1985 г.

Здесь перечисляются основные расширения С++ после 1985 г.:

Вообще язык С++ обладает большими возможностями и налагает меньше ограничений, чем ANSI C, поэтому большинство конструкций ANSI C являются законными для С++, причем смысл их не меняется. Исключения сводится к следующему:

В общем случае программа на С++ использует многие возможности, отсутствующие в ANSI C. Для такой программы незначительные расхождения, перечисленные в $$R.18.2, явно перекрываются расширениями в С++. Когда С++ и ANSI C должны иметь общие заголовочные файлы, нужно позаботиться, чтобы эти файлы представляли текст на общем подмножестве этих языков.

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

Можно использовать синтаксис С для определений функций:

Указатель на функцию-член некоторого объекта можно привести к указателю на какую-то другую функцию, например (int (*) ())p->f. Результирующий указатель будет настроен на функцию, вызов которой будет происходить с помощью обращения к этой функции-члену для того же объекта. Как обычно результат такого вызова считается неопределенным.

Если класс описан внутри другого класса и в программе больше не описано классов с этим именем, то его можно использовать, как если бы он был описан вне класса (так обстоит дело с описанием struct в С), например:

абстрактный абстрактный класс абстрактный описатель абстрактный тип данных (АТД) абстракция абстракция данных абстракция данных или наследование автоматические агрегат Ада аддитивные операции адрес адрес битового поля адрес и присваивание адрес конструктора Алгол68 американский национальный институт стандартов (ANSI) анахронизм анализатор рекурсивного спуска арифметика беззнакового арифметика фиксированной точности арифметическая особая ситуация арифметические операции с указателем арифметические преобразования арифметический тип ассемблер асинхронные события ассоциативность операций ассоциативный массив ассоциативность операций

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

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

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

единица трансляции

завершение программы заголовочный файл загрузчик закрытие потока запрос ресурса запуск особой ситуации запуск программы зарезервированный идентификатор защищенный член знаковый тип

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

макрокоманда макрокоманда препроцессора макрокоманда error макрокоманда null макрокоманда pragma макрообработка макроопределение макроподстановка макроподстановка (подстановка) манипулятор массив метка метка case метка default механизм вызова функции метод проектирования многомерный массив многосимвольная константа многоуровневая обработка ошибок множество символов ASCII множество символов EBCDIC множественное наследование модель каскад модульное программирование модульность мультипликативное-выражение

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

обобщенный пробел объединение область видимости область видимости friend область видимости вложенного класса область видимости имени область видимости класса область видимости локального класса область видимости макроимени область видимости макроопределения область видимости метки область видимости функции область видимости стандартного параметра обработка ошибок обработчик особой ситуации обратная дробная черта \ обратный вызов обширный интерфейс общий член класса объект объект-функция объектно-ориентированное программирование одиночная кавычка окружение программы операнд const операнд volatile операнд ссылка оператор оператор break оператор continue оператор do оператор for оператор goto оператор if оператор return оператор switch (переключатель) оператор while оператор выражения оператор итерации оператор описания оператор перехода оператор цикла оператор-выражение оператор-описание оператор-перехода операторная функция (operator) операционная система UNIX операция ! операция # операция ## операция %= операция && операция &= операция *= операция ++ операция += операция , операция -- операция -= операция /= операция :: операция <<= операция >>= операция ^= операция больше или равно операция больше чем операция ввода >> операция взятия адреса операция выбора члена класса операция вывода << операция вызова функции операция декремент операция запятая операция индексации операция инкремент операция косвенности операция логического отрицания операция логическое И операция логическое ИЛИ операция меньше или равно операция меньше чем операция неравно операция отношения операция преобразования операция приведения операция равенства операция присваивания операция-присваивания операция разрешения области видимости операция сдвига влево операция сложения операция условия ( ? : ) операция умножения операция унарный минус операция delete операция new операция sizeof описание описание asm описание extern описание friend описание register описание typedef описание битового поля описание в качестве определения описание внешних описание вложенного класса описание доступа описание дружественного класса описание или определение описание имени описание имени класса описание класса описание класса памяти описание локального класса описание массива описание параметра описание постоянного указателя описание ссылки описание статического члена описание стандартного параметра описание статического члена описание типа описание указателя описание функции описание функции-члена описание члена описание члена класса описание шаблона типа описание-шаблона-типа описание шаблонного класса описание шаблонной функции описание эллипсиса в функции описание-особой-ситуации описание-параметра описатель описатель-члена определение определение виртуальной функции определение класса определение конструктора определение области видимости функции определение объекта определение статического члена определение функции определение-функции определение функции-члена определение функции-члена inline определение шаблонного класса определение шаблонной функции определение чисто виртуальной функции определение члена определение шаблонного класса определение шаблонной функции определение элемента перечисления особая ситуация освобождение ресурса основной тип отладка отличия от вычисления выражений в С отличия от области видимости С отличия от описания функции в С отличия от пространства именования С отличия от связывания в С ошибка связывания

тело функции тип тип битового поля тип возвращаемого значения тип виртуальной функции тип конструктора тип массива тип строки тип указателя тип функции тип char тип double тип float тип int тип long тип long double тип short тип signed char тип unsigned char тип void тип volatile точка запуска триграф

узловой класс указание размещения указатель указатель на класс указатель на функцию указатель на функцию-член указатель типа void* указатель const унарное выражение унарная операция унарная-операция унарное выражение унарное-выражение уничтожение уничтожение автоматических уничтожение локальной переменной уничтожение локальных статических управление управление памятью управление свободной памятью управляющий класс управляющая последовательность управляющий символ (\) упрятывание имени уровни абстракции условная трансляция условный уточненное имя уточненное-имя уточненное-имя-класса уточненное-имя-типа

файл и поток файловая область видимости форматированный вывод функция функциональная макрокоманда функция-подстановка функция-член функция-член класса функция-член friend функция-член inline (подстановка) функция-член локального класса функция-член volatile функция-член объединения

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

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

шаблон типа шаблонный класс шаблонная функция шаблонная функция-член шаги проектирования шестнадцатеричная константа широкосимвольная строка

эквивалентность типов эквивалентность шаблонных типов элемент перечисления эллипсис ...

main() {

main () {

main() {

for ( int i= 0; i< 8; i++) {

main() {

extern void error(char *);

float pow(float x, int n) {

void error(char *s) {

// 1.11 class vector {

// 1.13 class vec : public vector {

main() {

extern void exit(int); // 1.13 void error(char* p) { cerr << p << "\n"; exit (1); }

// 1.11 vector::vector(int s) {

int& vector::operator[](int i) {

vector::~vector() {

// 1.13 int& vec::elem(int i) {

vec::vec(int lb, int hb) : (hb-lb+1) {

void vector::set_size(int) { /* dummy */ }

int& vec::operator[](int i) {

extern void exit( int ); extern void error( char* );

// 1.11 class vector {

vector::vector(int s) {

int& vector::operator[](int i) {

vector::~vector() {

// 1.14 class Vec : public vector { public:

Vec::Vec(Vec& a) : (a.size()) { int sz = a.size(); for (int i = 0; i<sz; i++) elem(i) =a.elem(i); }

void Vec::operator=(Vec& a) {

Vec operator+(Vec& a, Vec& b) {

void error(char* p) { cerr << p << "\n"; exit (1); }

void vector::set_size(int) { }

main() {

declare(vector,int); implement(vector,int);

main() {

int a = 1;

void f() {

main () {

main() {

extern int strlen(char*);

char alpha[] = "abcdefghijklmnopqrstuvwxyz";

main () {

char v[2][5] = {

main() {

main() {

struct pair {

const large = 1024; static pair vec[large];

pair* find(char* p) {

int& value(char* p) {

const MAX = 256;

main () {

enum token_value {

token_value curr_tok;

struct name {

const TBLSZ = 23; name* table[TBLSZ];

int no_of_errors;

double error(char* s) {

extern int strlen(const char*); extern int strcmp(const char*, const char*); extern char* strcpy(char*, const char*);

name* look(char* p, int ins = 0) {

inline name* insert(char* s) { return look (s,1); }

token_value get_token(); double term();

double expr() {

double prim();

double term() {

double prim() {

token_value get_token() {

int main(int argc, char* argv[]) {

char *save_string(char* p) {

int main (int argc, char* argv[]) {

extern void exit( int ); void out_of_store() {

typedef void (*PF)();

extern PF set_new_handler(PF);

main() {

#include <stream.hxx> #include <stdarg.hxx>

extern void exit(int); void error (int ...);

main(int argc, char* argv[]) {

void error(int n ...) {

struct user {

typedef user* Puser;

user heads[] = {

typedef int (*CFT)(char*,char*);

void sort(char* base, unsigned n, int sz, CFT cmp) {

void print_id(Puser v, int n) {

int cmp1(char* p, char* q) {

int cmp2(char* p, char* q) {

main () {

#include <stream.hxx>

class intset {

extern void exit (int);

void error(char *s) {

extern int atoi(char *);

extern int rand();

int randint (int u) // in the range 1..u {

intset::intset(int m, int n) {

intset::~intset() {

void intset::insert(int t) {

int intset::member(int t) {

void print_in_order(intset* set) {

main (int argc, char *argv[]) {

struct cl {

typedef void (cl::*PROC)(int);

main() {

#include "stream.hxx"

int error (char * p) {

class tiny {

void main() {

extern int strcpy(char* , char*);

extern int strlen(char *);

struct string {

string::string(char* s) {

void string::operator=(string& a) {

string::string(string& a) {

main() {

class assoc { pair * vec; int max; int free; public: assoc(int); int& operator[](char* ); void print_all(); };

assoc::assoc(int s) { max = (s<16) ? s: 16; free = 0; vec = new pair[max]; }

int& assoc::operator[](char * p) /*

void assoc::print_all() {

main() {

#include <stream.hxx> #include <string.h>

struct pair {

class assoc { friend class assoc_iterator;

assoc::assoc(int s) {

int& assoc::operator[](char* p) {

main() {

extern void exit(int); class string {

public:

string::string() {

string::string(char* s) {

string::~string() {

string& string::operator=(char* s) {

string& string::operator=(string& x) {

ostream& operator<<(ostream& s, string& x) {

istream& operator>>(istream& s, string& x) {

void error(char* p) {

main() {

struct employee { friend class manager;

struct manager : employee {

void employee::print() {

void manager::print() {

void f(employee* ll) {

main () {

#include <stream.hxx>

struct base { base(); };

struct derived : base { derived(); };

base:: base() {

derived::derived() {

main() {

#include <xstream.hxx>

extern void exit(int);

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

main(int argc, char* argv[]) {