10 Declarations [dcl.dcl]

Спецификаторы класса хранения:

storage-class-specifier:
	static
	thread_local
	extern
	mutable

Максимум один storage-class-specifierдолжен появиться в данном задании decl-specifier-seq, за исключением того, что thread_­local может появиться с помощью static или extern. Если он thread_­local появляется в любом объявлении переменной, он должен присутствовать во всех объявлениях этого объекта. Если a storage-class-specifier появляется в a decl-specifier-seq, в нем не может быть typedef спецификатора, decl-specifier-seqи init-declarator-listor member-declarator-list объявления не должно быть пустым (за исключением анонимного объединения, объявленного в именованном пространстве имен или в глобальном пространстве имен, которое должно быть объявлено static ([class.union.anon])). storage-class-specifierОтносится к имени , объявленному каждому init-declaratorв списке , а не какие - либо имена , объявленных другими спецификаторами. storage-class-specifier Кроме thread_­local не должно быть указано в explicit specialization или в explicit instantiation директиве.

[  Note: Переменная, объявленная без storage-class-specifier области действия блока или объявленная как параметр функции, automatic storage duration по умолчанию. ] — end note 

Спецификатор thread_­local указывает, что названный объект имеет thread storage duration. Он должен применяться только к именам переменных пространства имен или области блока и к именам статических элементов данных. Когда thread_­local применяется к переменной области блока storage-class-specifier static , подразумевается, если storage-class-specifierв decl-specifier-seq.

Спецификатор static может применяться только к именам переменных и функций и к anonymous unions. Внутриstatic блока не может быть ни объявлений функций, ни каких-либо static параметров функции. static Спецификатор используется в объявлении переменной объявляет переменную , чтобы static storage duration, если не будет сопровождаться thread_­local спецификатора, который объявляет переменную иметь thread storage duration. static Спецификатор можно использовать в объявлениях членов класса; [class.static] описывает его эффект. О связи имени, объявленного с помощью static спецификатора, см [basic.link].

Спецификатор extern можно применять только к именам переменных и функций. Спецификатор extern нельзя использовать в объявлении членов класса или параметров функции. О связи имени, объявленного с помощью спецификатора, см . [ Ключевое слово также может быть использовано в и , но это не в таких условиях. ] extern [basic.link] Note: extern explicit-instantiations linkage-specificationsstorage-class-specifier — end note 

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

static char* f();               // f() has internal linkage
char* f()                       // f() still has internal linkage
  { /* ... */ }

char* g();                      // g() has external linkage
static char* g()                // error: inconsistent linkage
  { /* ... */ }

void h();
inline void h();                // external linkage

inline void l();
void l();                       // external linkage

inline void m();
extern void m();                // external linkage

static void n();
inline void n();                // internal linkage

static int a;                   // a has internal linkage
int a;                          // error: two definitions

static int b;                   // b has internal linkage
extern int b;                   // b still has internal linkage

int c;                          // c has external linkage
static int c;                   // error: inconsistent linkage

extern int d;                   // d has external linkage
static int d;                   // error: inconsistent linkage

 — end example ]

В объявлении можно использовать имя объявленного, но неопределенного класса extern . Такое объявление может использоваться только способами, не требующими полного типа класса. [ Example:

struct S;
extern S a;
extern S f();
extern void g(S);

void h() {
  g(a);                         // error: S is incomplete
  f();                          // error: S is incomplete
}

 — end example ]

Спецификатор mutable должен появляться только в объявлении объекта non-static data member , тип которого не является ни константным, ни ссылочным типом. [ Example:

class X {
  mutable const int* p;         // OK
  mutable int* const q;         // ill-formed
};

 — end example ]

Спецификатор mutable члена данных класса обнуляет const спецификатор, примененный к содержащему объекту классу, и разрешает модификацию изменяемого члена класса, даже если остальной частью объекта является const ([dcl.type.cv]).

Function-specifiers может использоваться только в объявлениях функций.

function-specifier:
	virtual
	explicit

Спецификатор virtual должен использоваться только в начальном объявлении нестатической функции-члена класса; см [class.virtual].

Спецификатор explicit должен использоваться только в объявлении конструктора или функции преобразования в определении его класса; видеть [class.conv.ctor] и [class.conv.fct].

Объявления, содержащие decl-specifier typedef идентификаторы объявления, которые можно использовать позже для именования fundamental или compound типов. Спецификатор typedef не должен сочетаться в a decl-specifier-seqс любым другим типом спецификатора, кроме a defining-type-specifier, и он не должен использоваться ни в decl-specifier-seqa, parameter-declarationни в decl-specifier-seqa function-definition([dcl.fct.def]). Если typedef спецификатор появляется в объявлении без символа declarator, программа имеет неправильный формат.

typedef-name:
	identifier

Имя, объявленное с помощью typedef спецификатора, становится typedef-name. В рамках своего объявления a typedef-nameсинтаксически эквивалентен ключевому слову и называет тип, связанный с идентификатором, способом, описанным в пункте [dcl.decl]. Таким образом, А является синонимом другого типа. A не вводит новый тип, как это делает объявление класса ( ) или объявление перечисления. [ Послеtypedef-nametypedef-name[class.name] Example:

typedef int MILES, *KLICKSP;

конструкции

MILES distance;
extern KLICKSP metricp;

все правильные объявления; тип distance is int и тип metricp is «указатель на int». ] — end example 

A typedef-nameтакже может быть введено через alias-declaration. identifierВслед за using ключевым словом становится typedef-name и опциональным attribute-specifier-seqследуя identifierвходит в этот typedef-name. Такой объект typedef-nameимеет такую ​​же семантику, как если бы он был введен typedef спецификатором. В частности, он не определяет новый тип. [ Example:

using handler_t = void (*)(int);
extern handler_t ignore;
extern void (*ignore)(int);         // redeclare ignore
using cell = pair<void*, cell*>;    // ill-formed

 — end example ] defining-type-specifier-seq Из defining-type-idне определяет класс или перечисление , если alias-declaration это declarationиз template-declaration.

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

typedef struct s { /* ... */ } s;
typedef int I;
typedef int I;
typedef I I;

 — end example ]

В заданной области действия класса typedef спецификатор может использоваться для переопределения любого class-nameобъявленного в этой области действия, который не является также typedef-nameссылкой на тип, на который он уже ссылается. [ Example:

struct S {
  typedef struct A { } A;       // OK
  typedef struct B B;           // OK
  typedef A A;                  // error
};

 — end example ]

Если typedef спецификатор используется для переопределения в данной области сущности, на которую можно ссылаться с помощью elaborated-type-specifier, на эту сущность можно продолжать ссылаться с помощью elaborated-type-specifierили как перечисление или имя класса в перечислении или определении класса соответственно. [ Example:

struct S;
typedef struct S S;
int main() {
  struct S* p;                  // OK
}
struct S { };                   // OK

 — end example ]

В данной области typedef спецификатор не должен использоваться для переопределения имени любого типа, объявленного в этой области, для ссылки на другой тип. [ Example:

class complex { /* ... */ };
typedef int complex;            // error: redefinition

 — end example ]

Точно так же в данной области действия класс или перечисление не должны объявляться с тем же именем, что и объект typedef-name, объявленный в этой области, и относится к типу, отличному от самого класса или перечисления. [ Example:

typedef int complex;
class complex { /* ... */ };    // error: redefinition

 — end example ]

[ Имя типа класса или его cv-квалифицированная версия также является ( ). Если a используется для идентификации объекта , определения, объявления или объявления, программа имеет неправильный формат . ] [ Note: typedef-nameclass-name[class.name]typedef-nameelaborated-type-specifier class constructor destructor  — end note  Example:

struct S {
  S();
  ~S();
};

typedef struct S T;

S a = T();                      // OK
struct T * p;                   // error

 — end example ]

Если объявление typedef определяет безымянный класс (или перечисление), первый typedef-nameобъявленный в объявлении тип этого класса (или тип перечисления) используется для обозначения типа класса (или типа перечисления) только для целей связывания ([basic.link]). [ Example:

typedef struct { } *ps, S;      // S is the class name for linkage purposes

 — end example ]

Спецификатор friend используется для указания доступа к членам класса; см [class.friend].

Спецификатор constexpr должен применяться только к определению переменной или шаблона переменной или к объявлению функции или шаблона функции. Функция или статический член данных, объявленный с помощью constexpr спецификатора, неявно является встроенной функцией или переменной ([dcl.inline]). Если какое-либо объявление функции или шаблона функции имеет constexpr спецификатор, то все его объявления должны содержать constexpr спецификатор. [  Note: Явная специализация может отличаться от объявления шаблона в отношении constexpr спецификатора. ] [ Параметры функции не могут быть объявлены . ] [  — end note  Note: constexpr — end note  Example:

constexpr void square(int &x);  // OK: declaration
constexpr int bufsz = 1024;     // OK: definition
constexpr struct pixel {        // error: pixel is a type
  int x;
  int y;
  constexpr pixel(int);         // OK: declaration
};
constexpr pixel::pixel(int a)
  : x(a), y(x)                  // OK: definition
  { square(x); }
constexpr pixel small(2);       // error: square not defined, so small(2)
                                // not constant ([expr.const]) so constexpr not satisfied

constexpr void square(int &x) { // OK: definition
  x *= x;
}
constexpr pixel large(4);       // OK: square defined
int next(constexpr int x) {     // error: not for parameters
     return x + 1;
}
extern constexpr int memsz;     // error: not a definition

 — end example ]

constexpr Спецификатор используется в объявлении функции, не конструктор заявляет , что функция будет constexpr function. Точно так же constexpr спецификатор, используемый в объявлении конструктора, объявляет, что этот конструктор является constexpr constructor.

Определение функции constexpr должно удовлетворять следующим требованиям:

• (3.1)

  не должно быть virtual;

• (3.2)

  его возвращаемый тип должен быть буквальным;

• (3.3)

  каждый из его типов параметров должен быть буквальным типом;

• (3.4)

  это function-bodyдолжно быть = delete, = defaultили, compound-statement которое не содержит

  • (3.4.1)

    ан asm-definition,

  • (3.4.2)

    goto заявление,

  • (3.4.3)

    ан identifier label,

  • (3.4.4)

    а try-block, или

  • (3.4.5)

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

[ Example:

constexpr int square(int x)
  { return x * x; }             // OK
constexpr long long_max()
  { return 2147483647; }        // OK
constexpr int abs(int x) {
  if (x < 0)
    x = -x;
  return x;                     // OK
}
constexpr int first(int n) {
  static int value = n;         // error: variable has static storage duration
  return value;
}
constexpr int uninit() {
  int a;                        // error: variable is uninitialized
  return a;
}
constexpr int prev(int x)
  { return --x; }               // OK
constexpr int g(int x, int n) { // OK
  int r = 1;
  while (--n > 0) r *= x;
  return r;
}

 — end example ]

Определение конструктора constexpr должно удовлетворять следующим требованиям:

• (4.1)

  у класса не должно быть никаких виртуальных базовых классов;

• (4.2)

  каждый из типов параметров должен быть буквальным типом;

• (4.3)

  его function-bodyне должно быть function-try-block.

Кроме того, он либо function-bodyдолжен быть = delete, либо удовлетворять следующим требованиям:

• (4.4)

  либо его function-bodyдолжно быть = default, либо compound-statementего function-body должно удовлетворять требованиям для function-bodyфункции constexpr;

• (4.5)

  каждый невариантный нестатический член данных и подобъект базового класса должен быть инициализирован ([class.base.init]);

• (4.6)

  если класс является объединением, имеющим вариантные члены ([class.union]), должен быть инициализирован ровно один из них;

• (4.7)

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

• (4.8)

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

• (4.9)

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

[ Example:

struct Length {
  constexpr explicit Length(int i = 0) : val(i) { }
private:
  int val;
};

 — end example ]

Для функции constexpr или конструктора constexpr, который не является ни заданным по умолчанию, ни шаблоном, если не существует таких значений аргументов, что вызов функции или конструктора мог быть вычисленным подвыражением a core constant expression, или, для конструктора, константным инициализатором для некоторого объекта ([basic.start.static]), программа некорректна, диагностика не требуется. [ Example:

constexpr int f(bool b)
  { return b ? throw 0 : 0; }           // OK
constexpr int f() { return f(true); }   // ill-formed, no diagnostic required

struct B {
  constexpr B(int x) : i(0) { }         // x is unused
  int i;
};

int global;

struct D : B {
  constexpr D() : B(global) { }         // ill-formed, no diagnostic required
                                        // lvalue-to-rvalue conversion on non-constant global
};

 — end example ]

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

Вызов функции constexpr дает тот же результат, что и вызов эквивалентной функции non-constexpr во всех отношениях, за исключением того, что

• (7.1)

  вызов функции constexpr может появиться в constant expression и

• (7.2)

  copy elision является обязательным в постоянном выражении ([class.copy]).

Спецификатор constexpr не влияет на тип функции constexpr или конструктора constexpr. [ Example:

constexpr int bar(int x, int y)         // OK
    { return x + y + x*y; }
// ...
int bar(int x, int y)                   // error: redefinition of bar
    { return x * 2 + 3 * y; }

 — end example ]

constexpr Спецификатор используется в объявлении объекта объявляет объект как const. Такой объект должен иметь буквальный тип и быть инициализирован. В любом constexpr объявлении переменной полное выражение инициализации должно быть constant expression. [ Example:

struct pixel {
  int x, y;
};
constexpr pixel ur = { 1294, 1024 };    // OK
constexpr pixel origin;                 // error: initializer missing

 — end example ]

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

Объявление функции ([dcl.fct], [class.mfct], [class.friend]) с inline спецификатором объявляет какойinline function. Встроенный спецификатор указывает реализации, что встроенная подстановка тела функции в точке вызова предпочтительнее обычного механизма вызова функции. Реализация не требуется для выполнения этой встроенной замены в точке вызова; однако, даже если эта встроенная подстановка опущена, все равно должны соблюдаться другие правила для встроенных функций, указанные в этом разделе.

Объявление переменной со inline спецификатором объявляет inline variable.

Функция, определенная в определении класса, является встроенной функцией.

Спецификатор inline не должен появляться в объявлении области действия блока.94 Если inline спецификатор используется в объявлении дружественной функции, это объявление должно быть определением, или функция должна быть ранее объявлена ​​встроенной.

Встроенная функция или переменная должна быть определена в каждой единице перевода, в которой она используется odr, и должна иметь точно такое же определение во всех случаях ([basic.def.odr]). [  Note: Вызов встроенной функции или использование встроенной переменной может встречаться до того, как ее определение появится в блоке перевода. ] Если определение функции или переменной появляется в единице перевода перед ее первым объявлением как встроенное, программа имеет неправильный формат. Если функция или переменная с внешней связью объявляется встроенной в одной единице перевода, она должна быть объявлена ​​встроенной во всех единицах перевода, в которых она появляется; Диагностика не требуется. Встроенная функция или переменная с внешней связью должна иметь один и тот же адрес во всех единицах трансляции. [ Локальная переменная в инлайн функции с внешним связыванием всегда относится к тому же объекту. Тип, определенный в теле встроенной функции с внешней связью, является одним и тем же типом во всех единицах перевода. ] — end note  Note: static  — end note 

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

type-specifier:
	simple-type-specifier
	elaborated-type-specifier
	typename-specifier
	cv-qualifier

type-specifier-seq:
	type-specifier attribute-specifier-seq${}_{opt}$
	type-specifier type-specifier-seq

defining-type-specifier:
	type-specifier
	class-specifier
	enum-specifier

defining-type-specifier-seq:
	defining-type-specifier attribute-specifier-seq${}_{opt}$
	defining-type-specifier defining-type-specifier-seq

Необязательное attribute-specifier-seqв a type-specifier-seq или a defining-type-specifier-seq относится к типу, обозначенному предыдущим символом type-specifiers или defining-type-specifiers ([dcl.meaning]). Параметр attribute-specifier-seqвлияет на тип только для объявления, в котором он появляется, а не для других объявлений, связанных с тем же типом.

Как правило, defining-type-specifier разрешается не более одного в полном decl-specifier-seqa declarationили в a defining-type-specifier-seq, и не более одного type-specifier разрешается в a type-specifier-seq. Единственными исключениями из этого правила являются следующие:

• (2.1)

  const может сочетаться с любым спецификатором типа, кроме самого себя.

• (2.2)

  volatile может сочетаться с любым спецификатором типа, кроме самого себя.

• (2.3)

  signed или unsigned могут быть объединены с char, long, shortили int.

• (2.4)

  short или long можно комбинировать с int.

• (2.5)

  long можно комбинировать с double.

• (2.6)

  long можно комбинировать с long.

За исключением объявления конструктора, деструктора или функции преобразования, по крайней мере один, defining-type-specifierкоторый не является, cv-qualifierдолжен появиться в завершенном type-specifier-seqили завершенном виде decl-specifier-seq.95

[ , И обсуждаются в , п , и , соответственно. Остальные обсуждаются в оставшейся части этого раздела. ] Note: enum-specifiersclass-specifierstypename-specifiers[dcl.enum] [class][temp.res]type-specifiers  — end note