Declarations

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

Объявление представляет собой одно из следующих:

• Определение функции
• Объявление шаблона (включая Частичную специализацию шаблона )
• Явное инстанцирование шаблона
• Явная специализация шаблона
• Определение пространства имён
• Спецификация компоновки

• Пустое объявление ( ; )
• Объявление функции без decl-specifier-seq :

Данное объявление должно объявлять конструктор, деструктор или пользовательскую conversion function . Оно может использоваться только как часть template declaration , explicit specialization , или explicit instantiation.

• block-declaration (объявление, которое может находиться внутри блока ), которое, в свою очередь, может быть одним из следующих:

• объявление asm

• определение псевдонима пространства имён
• using-объявление
• using-директива

• простая декларация

Простое объявление

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

init-declarator-list может быть опущен только при объявлении именованного класса или именованного перечисления.

Синтаксис init-declarator определяется следующим образом:

Спецификаторы

Спецификаторы объявления ( decl-specifier-seq ) представляет собой последовательность следующих разделенных пробелами спецификаторов в произвольном порядке:

• спецификатор typedef . Если присутствует, вся декларация является typedef-декларацией , и каждый декларатор вводит новое имя типа, а не объект или функцию.
• спецификаторы функций ( inline , virtual , explicit ), разрешены только в декларациях функций .

• спецификатор friend , разрешённый в объявлениях классов и функций.

• спецификатор класса хранения ( register , (до C++17) static , thread_local , (начиная с C++11) extern , mutable ). Допускается только один спецификатор класса хранения , за исключением того, что thread_local может появляться вместе с extern или static (начиная с C++11) .
• Спецификаторы типа ( type-specifier-seq ), последовательность спецификаторов, которая задаёт тип. Тип каждой сущности, вводимой объявлением, является этим типом, опционально модифицированным декларатором (см. ниже). Эта последовательность спецификаторов также используется type-id . Только следующие спецификаторы являются частью type-specifier-seq , в любом порядке:

• спецификатор класса
• спецификатор перечисления
• спецификатор простого типа

• char , char8_t , (начиная с C++20) char16_t , char32_t , (начиная с C++11) wchar_t , bool , short , int , long , signed , unsigned , float , double , void

• ранее объявленное имя класса (опционально квалифицированное )
• ранее объявленное имя перечисления (опционально квалифицированное )
• ранее объявленное typedef-имя или псевдоним типа (начиная с C++11) (опционально квалифицированное )
• имя шаблона с аргументами шаблона (опционально квалифицированное , опционально с использованием дисквалификатора шаблона )

• уточняющий спецификатор типа

• ключевое слово class , struct , или union , за которым следует идентификатор (опционально квалифицированный ), ранее определённый как имя класса.
• ключевое слово class , struct , или union , за которым следует имя шаблона с аргументами шаблона (опционально квалифицированное , опционально с использованием template дисамбигуатора ), ранее определённое как имя шаблона класса.
• ключевое слово enum , за которым следует идентификатор (опционально квалифицированный ), ранее объявленный как имя перечисления.

• typename спецификатор
• cv-квалификатор

только один спецификатор типа разрешён в последовательности decl-specifier-seq, за следующими исключениями:

• const может комбинироваться с любым спецификатором типа, кроме самого себя.
• volatile может комбинироваться с любым спецификатором типа, кроме самого себя.
• signed или unsigned могут комбинироваться с char , long , short , или int .
• short или long могут комбинироваться с int .
• long может комбинироваться с double .

Атрибуты могут появляться в decl-specifier-seq , в этом случае они применяются к типу, определяемому предшествующими спецификаторами.

Повторения любого спецификатора в decl-specifier-seq , такие как const static const или virtual inline virtual являются ошибками , за исключением того, что long может появляться дважды (начиная с C++11) .

Деклараторы

Каждый init-declarator в init-declarator-list S D1, D2, D3 ; обрабатывается так, как если бы он был отдельным объявлением с теми же спецификаторами: S D1 ; S D2 ; S D3 ; .

Каждый декларатор вводит ровно один объект, ссылку, функцию или (для typedef-объявлений) псевдоним типа, чей тип задаётся decl-specifier-seq и опционально модифицируется операторами, такими как & (ссылка на) или [ ] (массив из) или ( ) (функция, возвращающая) в деклараторе. Эти операторы могут применяться рекурсивно, как показано ниже.

Объявитель declarator может быть одним из следующих:

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

Примечания

Когда block-declaration появляется внутри блока , и идентификатор, введённый объявлением, был ранее объявлен во внешнем блоке, внешнее объявление скрывается до конца блока.

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

Пример

#include <type_traits>
struct S
{
    int member;
    // decl-specifier-seq is "int"
    // declarator is "member"
} obj, *pObj(&obj);
// decl-specifier-seq is "struct S { int member; }"
// declarator "obj" declares an object of type S
// declarator "*pObj" declares a pointer to S,
//     and initializer "(&obj)" initializes it
int i = 1, *p = nullptr, f(), (*pf)(double);
// decl-specifier-seq is "int"
// declarator "i" declares a variable of type int,
//     and initializer "= 1" initializes it
// declarator "*p" declares a variable of type int*,
//     and initializer "= nullptr" initializes it
// declarator "f()" declares (but doesn't define)
//     a function taking no arguments and returning int
// declarator "(*pf)(double)" declares a pointer to function
//     taking double and returning int
int (*(*var1)(double))[3] = nullptr;
// decl-specifier-seq is "int"
// declarator is "(*(*var1)(double))[3]"
// initializer is "= nullptr"
// 1. declarator "(*(*var1)(double))[3]" is an array declarator:
//    Type declared is: "(*(*var1)(double))" array of 3 elements
// 2. declarator "(*(*var1)(double))" is a pointer declarator:
//    Type declared is: "(*var1)(double)" pointer to array of 3 elements
// 3. declarator "(*var1)(double)" is a function declarator:
//    Type declared is: "(*var1)" function taking "(double)",
//    returning pointer to array of 3 elements.
// 4. declarator "(*var1)" is a pointer declarator:
//    Type declared is: "var1" pointer to function taking "(double)",
//    returning pointer to array of 3 elements.
// 5. declarator "var1" is an identifier.
// This declaration declares the object var1 of type "pointer to function
// taking double and returning pointer to array of 3 elements of type int"
// The initializer "= nullptr" provides the initial value of this pointer.
// C++11 alternative syntax:
auto (*var2)(double) -> int (*)[3] = nullptr;
// decl-specifier-seq is "auto"
// declarator is "(*var2)(double) -> int (*)[3]"
// initializer is "= nullptr"
// 1. declarator "(*var2)(double) -> int (*)[3]" is a function declarator:
//    Type declared is: "(*var2)" function taking "(double)", returning "int (*)[3]"
// ...
int main()
{
    static_assert(std::is_same_v<decltype(var1), decltype(var2)>);
}

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены задним числом к ранее опубликованным стандартам C++.

Смотрите также