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 

Каждый namespace-definitionдолжен появиться в глобальной области видимости или в области видимости пространства имен ([basic.scope.namespace]).

В named-namespace-definition, то identifierэто имя пространства имен. Если identifierпри поиске ([basic.lookup.unqual]) относится к namespace-name(но не a namespace-alias), которое было введено в пространство имен, в котором named-namespace-definitionпоявляется, или которое было введено в члене встроенного набора пространств имен этого пространства имен, namespace-definition extends ранее объявленное пространство имен. В противном случае identifierвводится как namespace-nameв декларативную область, в которой named-namespace-definitionпоявляется.

Поскольку a namespace-definitionсодержится declarations в его, namespace-bodyа a namespace-definitionсамо является a declaration, отсюда следует, что он namespace-definitions может быть вложенным. [ Example:

namespace Outer {
  int i;
  namespace Inner {
    void f() { i++; }           // Outer​::​i
    int i;
    void g() { i++; }           // Inner​::​i
  }
}

 — end example ]

Объектами enclosing namespaces объявления являются те пространства имен, в которых объявление появляется лексически, за исключением повторного объявления члена пространства имен вне его исходного пространства имен (например, определения, как указано в [namespace.memdef]). Такое повторное объявление имеет те же охватывающие пространства имен, что и исходное объявление. [ Example:

namespace Q {
  namespace V {
    void f();                   // enclosing namespaces are the global namespace, Q, and Q​::​V
    class C { void m(); };
  }
  void V::f() {                 // enclosing namespaces are the global namespace, Q, and Q​::​V
    extern void h();            // ... so this declares Q​::​V​::​h
  }
  void V::C::m() {              // enclosing namespaces are the global namespace, Q, and Q​::​V
  }
}

 — end example ]

Если необязательное начальное inline ключевое слово появляется в a namespace-definitionдля определенного пространства имен, это пространство имен объявляется inline namespace. inline Ключевое слово может быть использовано на namespace-definitionкоторый расширяет пространство имен , только если он был ранее использован на namespace-definition том , что изначально объявлено namespace-nameдля этого пространства имен.

Необязательный параметр attribute-specifier-seq в a named-namespace-definition принадлежит определяемому или расширяемому пространству имен.

Члены встроенного пространства имен можно использовать во многих отношениях, как если бы они были членами включающего пространства имен. В частности, встроенное пространство имен и его включающее пространство имен добавляются к набору связанных пространств имен, используемых argument-dependent lookup всякий раз, когда одно из них есть, а элемент, using-directiveкоторый именует встроенное пространство имен, неявно вставляется во включающее пространство имен, как для unnamed namespace. Кроме того, каждый член инлайн пространства имен может впоследствии быть partially specialized, explicitly instantiatedили , explicitly specialized как если бы она была членом пространства имен вмещающих. Наконец, поиск имени в охватывающем пространстве имен с помощью явной qualification ([namespace.qual]) будет включать элементы встроенного пространства имен, внесенных с помощью, using-directiveдаже если есть объявления этого имени во включающем пространстве имен.

Эти свойства являются транзитивными: если пространство имен N содержит встроенное пространство имен M, которое, в свою очередь, содержит встроенное пространство имен O, тогда члены O могут использоваться, как если бы они были членами M или N. inline namespace set Из N является транзитивным замыканием всех встроенных пространств имен в N. enclosing namespace set Из O есть множество пространств имен , состоящие из самих внутренних без встроенного пространства имен , охватывающего инлайн пространства имен O, вместе с любыми промежуточным инлайн пространствами имен.

A nested-namespace-definitionс символом enclosing-namespace-specifier E, identifier I и namespace-body B эквивалентно

namespace E { namespace I { B } }

[ Example:

namespace A::B::C {
  int i;
}

Вышеупомянутое имеет тот же эффект, что и:

namespace A {
  namespace B {
    namespace C {
      int i;
    }
  }
}

 — end example ]

A namespace-alias-definitionобъявляет альтернативное имя для пространства имен в соответствии со следующей грамматикой:

namespace-alias:
	identifier

namespace-alias-definition:
	namespace identifier = qualified-namespace-specifier ;

qualified-namespace-specifier:
	nested-name-specifier${}_{opt}$ namespace-name

Символ identifierв a namespace-alias-definitionявляется синонимом имени пространства имен, обозначаемого символом qualified-namespace-specifierи становится a namespace-alias. [  Note: При поиске a namespace-nameв a namespace-alias-definitionучитываются только имена пространств имен, см [basic.lookup.udir]. ] — end note 

В декларативной области a namespace-alias-definitionможно использовать для переопределения, namespace-aliasобъявленного в этой декларативной области, чтобы ссылаться только на пространство имен, на которое оно уже ссылается. [  Example: Следующие декларации составлены правильно:

namespace Company_with_very_long_name { /* ... */ }
namespace CWVLN = Company_with_very_long_name;
namespace CWVLN = Company_with_very_long_name;  // OK: duplicate
namespace CWVLN = CWVLN;

 — end example ]

Каждый using-declaratorв a using-declaration98 вводит набор объявлений в декларативную область, в которой using-declarationпоявляется. Набор объявлений, представленных объектом, using-declaratorнаходится путем выполнения поиска по квалифицированному имени ([basic.lookup.qual], [class.member.lookup]) для имени в using-declarator, за исключением функций, которые скрыты, как описано ниже. Если using-declaratorне называет конструктор, unqualified-idобъявляется в декларативной области, в которой using-declarationпоявляется как синоним для каждого объявления, представленного using-declarator. [  Note: Так объявляется только указанное имя; указание имени перечисления в a using-declaration не объявляет его перечислители в using-declarationдекларативной области. ] Если именует конструктор, он объявляет, что класс - это набор объявлений конструктора, представленных от назначенного базового класса. — end note using-declarator inherits using-declarator

Every using-declaration- это a declarationи a, member-declarationпоэтому их можно использовать в определении класса. [ Example:

struct B {
  void f(char);
  void g(char);
  enum E { e };
  union { int x; };
};

struct D : B {
  using B::f;
  void f(int) { f('c'); }       // calls B​::​f(char)
  void g(int) { g('c'); }       // recursively calls D​::​g(int)
};

 — end example ]

В using-declarationиспользуются в качестве member-declaration, каждый using-declarator«s nested-name-specifier будет называть базовый класс определяемым класса. Если a using-declaratorназывает конструктор, он nested-name-specifierдолжен называть прямой базовый класс определяемого класса. [ Example:

template <typename... bases>
struct X : bases... {
  using bases::g...;
};

X<B, D> x;                      // OK: B​::​g and D​::​g introduced

 — end example ] [ Example:

class C {
  int g();
};

class D2 : public B {
  using B::f;                   // OK: B is a base of D2
  using B::e;                   // OK: e is an enumerator of base B
  using B::x;                   // OK: x is a union member of base B
  using C::g;                   // error: C isn't a base of D2
};

 — end example ]

[  Note: Поскольку деструкторы не имеют имен, a using-declarationне может ссылаться на деструктор базового класса. Поскольку специализации шаблонов членов для функций преобразования не могут быть найдены с помощью поиска по имени, они не учитываются, когда a using-declarationуказывает функцию преобразования ([temp.mem]). ] Если конструктор или оператор присваивания, перенесенный из базового класса в производный класс, имеет сигнатуру конструктора копирования / перемещения или оператора присваивания для производного класса ( ), сам по себе не подавляет неявное объявление члена производного класса; член базового класса скрыт или переопределен неявно объявленным конструктором копирования / перемещения или оператором присваивания производного класса, как описано ниже. — end note [class.copy]using-declaration

A using-declarationне должен называть a template-id. [ Example:

struct A {
  template <class T> void f(T);
  template <class T> struct X { };
};
struct B : A {
  using A::f<double>;           // ill-formed
  using A::X<int>;              // ill-formed
};

 — end example ]

A using-declarationне должен называть пространство имен.

A using-declarationне должен называть перечислителя с ограниченной областью видимости.

Имя using-declarationчлена класса должно быть member-declaration. [ Example:

struct X {
  int i;
  static int s;
};

void f() {
  using X::i;                   // error: X​::​i is a class member and this is not a member declaration.
  using X::s;                   // error: X​::​s is a class member and this is not a member declaration.
}

 — end example ]

На члены, объявленные a, using-declarationможно ссылаться с помощью явной квалификации, как и на другие имена членов ([namespace.qual]). [ Example:

void f();

namespace A {
  void g();
}

namespace X {
  using ::f;                    // global f
  using A::g;                   // A's g
}

void h()
{
  X::f();                       // calls ​::​f
  X::g();                       // calls A​::​g
}

 — end example ]

A using-declaration- это a declarationи поэтому может использоваться повторно там, где (и только когда) разрешено несколько объявлений. [ Example:

namespace A {
  int i;
}

namespace A1 {
  using A::i, A::i;             // OK: double declaration
}

struct B {
  int i;
};

struct X : B {
  using B::i, B::i;             // error: double member declaration
};

 — end example ]

[  Note: Для элемента, using-declaration чьи nested-name-specifierимена являются пространством имен, члены, добавленные к пространству имен после элемента using-declaration , не входят в набор представленных объявлений, поэтому они не учитываются при использовании имени. Таким образом, дополнительные перегрузки, добавленные после using-declaration, игнорируются, но учитываются аргументы функции по умолчанию ([dcl.fct.default]), аргументы шаблона по умолчанию ([temp.param]) и специализации шаблона ([temp.class.spec], [temp.expl.spec]). ] [  — end note  Example:

namespace A {
  void f(int);
}

using A::f;         // f is a synonym for A​::​f; that is, for A​::​f(int).
namespace A {
  void f(char);
}

void foo() {
  f('a');           // calls f(int), even though f(char) exists.
}

void bar() {
  using A::f;       // f is a synonym for A​::​f; that is, for A​::​f(int) and A​::​f(char).
  f('a');           // calls f(char)
}

 — end example ]

[  Note: Частичные специализации шаблонов классов можно найти путем поиска основного шаблона класса и последующего рассмотрения всех частичных специализаций этого шаблона. Если a using-declarationназывает шаблон класса, частичные специализации, введенные после using-declaration, фактически видны, потому что первичный шаблон является видимым ([temp.class.spec]). ] — end note 

Поскольку a using-declarationявляется объявлением, ограничения на одноименное объявление в нем declarative region также применяются к using-declarations. [ Example:

namespace A {
  int x;
}

namespace B {
  int i;
  struct g { };
  struct x { };
  void f(int);
  void f(double);
  void g(char);     // OK: hides struct g
}

void func() {
  int i;
  using B::i;       // error: i declared twice
  void f(char);
  using B::f;       // OK: each f is a function
  f(3.5);           // calls B​::​f(double)
  using B::g;
  g('a');           // calls B​::​g(char)
  struct g g1;      // g1 has class type B​::​g
  using B::x;
  using A::x;       // OK: hides struct B​::​x
  x = 99;           // assigns to A​::​x
  struct x x1;      // x1 has class type B​::​x
}

 — end example ]

Если объявление функции в области пространства имен или области блока имеет то же имя и то же самое, parameter-type-list что и функция, представленная с помощью a using-declaration, и объявления не объявляют ту же функцию, программа имеет неправильный формат. Если объявление шаблона функции в области пространства имен имеет то же имя, список типов параметров, возвращаемый тип и список параметров шаблона, что и шаблон функции, введенный с помощью a using-declaration, программа имеет неправильный формат. [  Note: Двое using-declarations могут вводить функции с одним и тем же именем и одним и тем же списком типов параметров. Если для вызова неквалифицированного имени функции разрешение перегрузки функции выбирает функции, введенные таким образом using-declarations, вызов функции имеет неправильный формат. [ Example:

namespace B {
  void f(int);
  void f(double);
}
namespace C {
  void f(int);
  void f(double);
  void f(char);
}

void h() {
  using B::f;       // B​::​f(int) and B​::​f(double)
  using C::f;       // C​::​f(int), C​::​f(double), and C​::​f(char)
  f('h');           // calls C​::​f(char)
  f(1);             // error: ambiguous: B​::​f(int) or C​::​f(int)?
  void f(int);      // error: f(int) conflicts with C​::​f(int) and B​::​f(int)
}

 — end example ] ] — end note 

Когда a using-declaratorпереносит объявления из базового класса в производный класс, функции-члены и шаблоны функций-членов в производном классе переопределяют и / или скрывают функции-члены и шаблоны функций-членов с тем же именем parameter-type-list,, cv-qualification и ref-qualifier(если есть) в базовый класс (а не конфликтующий). Такие скрытые или переопределенные объявления исключаются из набора объявлений, введенных платформой using-declarator. [ Example:

struct B {
  virtual void f(int);
  virtual void f(char);
  void g(int);
  void h(int);
};

struct D : B {
  using B::f;
  void f(int);      // OK: D​::​f(int) overrides B​::​f(int);

  using B::g;
  void g(char);     // OK

  using B::h;
  void h(int);      // OK: D​::​h(int) hides B​::​h(int)
};

void k(D* p)
{
  p->f(1);          // calls D​::​f(int)
  p->f('a');        // calls B​::​f(char)
  p->g(1);          // calls B​::​g(int)
  p->g('a');        // calls D​::​g(char)
}

struct B1 {
  B1(int);
};

struct B2 {
  B2(int);
};

struct D1 : B1, B2 {
  using B1::B1;
  using B2::B2;
};
D1 d1(0);           // ill-formed: ambiguous

struct D2 : B1, B2 {
  using B1::B1;
  using B2::B2;
  D2(int);          // OK: D2​::​D2(int) hides B1​::​B1(int) and B2​::​B2(int)
};
D2 d2(0);           // calls D2​::​D2(int)

 — end example ]

В целях разрешения перегрузки функции, которые вводятся using-declarationв производный класс, обрабатываются так, как если бы они были членами производного класса. В частности, неявный this параметр следует рассматривать как указатель на производный класс, а не на базовый класс. Это не влияет на тип функции, и во всех других отношениях функция остается членом базового класса. Кроме того, конструкторы, которые вводятся через А using-declaration , рассматриваются как если бы они были конструкторами производного класса при поиске конструкторов производного класса ([class.qual]) или формирования набора кандидатов перегрузки ([over.match.ctor], [over.match.copy], [over.match.list]). Если такой конструктор выбран для выполнения инициализации объекта типа класса, все подобъекты, кроме базового класса, из которого произошел конструктор, инициализируются неявно ([class.inhctor.init]).

В a using-declarator, который не называет конструктор, все члены набора введенных объявлений должны быть доступны. В элементе, using-declaratorкоторый называет конструктор, проверка доступа не выполняется. В частности, если производный класс использует using-declaratorдля доступа к члену базового класса, имя члена должно быть доступно. Если имя совпадает с именем перегруженной функции-члена, тогда все указанные функции должны быть доступны. Члены базового класса, упомянутые a, using-declaratorдолжны быть видимы в области видимости по крайней мере одного из прямых базовых классов класса, в котором using-declaratorуказан.

[  Note: Поскольку a using-declaratorобозначает член базового класса (а не подобъект члена или функцию члена подобъекта базового класса), a using-declaratorнельзя использовать для разрешения унаследованных двусмысленностей членов. [ Example:

struct A { int x(); };
struct B : A { };
struct C : A {
  using A::x;
  int x(int);
};

struct D : B, C {
  using C::x;
  int x(double);
};
int f(D* d) {
  return d->x();    // error: overload resolution selects A​::​x, but A is an ambiguous base class
}

 — end example ] ] — end note 

Синоним, созданный a, using-declarationимеет обычную доступность для a member-declaration. Объект, using-declaratorкоторый называет конструктор, не создает синоним; вместо этого дополнительные конструкторы доступны, если они будут доступны при использовании для создания объекта соответствующего базового класса, а доступность using-declarationигнорируется. [ Example:

class A {
private:
    void f(char);
public:
    void f(int);
protected:
    void g();
};

class B : public A {
  using A::f;       // error: A​::​f(char) is inaccessible
public:
  using A::g;       // B​::​g is a public synonym for A​::​g
};

 — end example ]

Если a using-declaratorиспользует ключевое слово typename и указывает зависимое имя ([temp.dep]), имя, введенное с помощью using-declaration, обрабатывается как typedef-name.

A using-directiveне должен появляться в области класса, но может появляться в области пространства имен или в области блока. [  Note: При поиске a namespace-nameв a using-directiveучитываются только имена пространств имен, см [basic.lookup.udir]. ] Необязательный элемент принадлежит к . — end note attribute-specifier-sequsing-directive

A using-directiveуказывает, что имена в назначенном пространстве имен могут использоваться в области, в которой using-directiveпоявляется после using-directive. При unqualified name lookupэтом имена выглядят так, как если бы они были объявлены в ближайшем охватывающем пространстве имен, которое содержит как пространство имен, так using-directiveи назначенное пространство имен. [  Note: В этом контексте «содержит» означает «содержит прямо или косвенно». ] — end note 

A using-directiveне добавляет элементы в декларативную область, в которой находится. [ Example:

namespace A {
  int i;
  namespace B {
    namespace C {
      int i;
    }
    using namespace A::B::C;
    void f1() {
      i = 5;        // OK, C​::​i visible in B and hides A​::​i
    }
  }
  namespace D {
    using namespace B;
    using namespace C;
    void f2() {
      i = 5;        // ambiguous, B​::​C​::​i or A​::​i?
    }
  }
  void f3() {
    i = 5;          // uses A​::​i
  }
}
void f4() {
  i = 5;            // ill-formed; neither i is visible
}

 — end example ]

Для получения unqualified lookup, то using-directiveтранзитивность: если сфера содержит , using-directiveчто выдвигает второе пространство имен , которое само по себе содержит using-directives, эффект , как если бы using-directives из второго пространства имен также появилась в первом. [  Note: Для квалифицированного поиска см [namespace.qual]. ] [  — end note  Example:

namespace M {
  int i;
}

namespace N {
  int i;
  using namespace M;
}

void f() {
  using namespace N;
  i = 7;            // error: both M​::​i and N​::​i are visible
}

Другой пример:

namespace A {
  int i;
}
namespace B {
  int i;
  int j;
  namespace C {
    namespace D {
      using namespace A;
      int j;
      int k;
      int a = i;    // B​::​i hides A​::​i
    }
    using namespace D;
    int k = 89;     // no problem yet
    int l = k;      // ambiguous: C​::​k or D​::​k
    int m = i;      // B​::​i hides A​::​i
    int n = j;      // D​::​j hides B​::​j
  }
}

 — end example ]

Если пространство имен находится extended после a using-directiveдля этого пространства имен, дополнительные члены расширенного пространства имен и члены пространств имен, назначенные using-directives в расширении, namespace-definitionмогут использоваться после расширения namespace-definition.

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

namespace A {
  class X { };
  extern "C"   int g();
  extern "C++" int h();
}
namespace B {
  void X(int);
  extern "C"   int g();
  extern "C++" int h(int);
}
using namespace A;
using namespace B;

void f() {
  X(1);             // error: name X found in two namespaces
  g();              // OK: name g refers to the same entity
  h();              // OK: overload resolution selects A​::​h
}

 — end note ]

Во время разрешения перегрузки все функции из транзитивного поиска рассматриваются для сопоставления аргументов. Набор объявлений, найденных при переходном поиске, неупорядочен. [  Note: В частности, порядок, в котором рассматривались пространства имен, и отношения между пространствами имен, подразумеваемые using-directives элементом, не приводят к тому, что предпочтение отдается никаким объявлениям, найденным в результате поиска. ] Двусмысленность существует, если наилучшее соответствие находит две функции с одинаковой сигнатурой, даже если одна находится в пространстве имен, доступном через пространство имен другой. [ — end note using-directives 99 Example:

namespace D {
  int d1;
  void f(char);
}
using namespace D;

int d1;             // OK: no conflict with D​::​d1

namespace E {
  int e;
  void f(int);
}

namespace D {       // namespace extension
  int d2;
  using namespace E;
  void f(int);
}

void f() {
  d1++;             // error: ambiguous ​::​d1 or D​::​d1?
  ::d1++;           // OK
  D::d1++;          // OK
  d2++;             // OK: D​::​d2
  e++;              // OK: E​::​e
  f(1);             // error: ambiguous: D​::​f(int) or E​::​f(int)?
  f('a');           // OK: D​::​f(char)
}

 — end example ]

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

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

attribute-specifier:
	[ [ attribute-using-prefix${}_{opt}$ attribute-list ] ]
	alignment-specifier

alignment-specifier:
	alignas ( type-id ...${}_{opt}$ )
	alignas ( constant-expression ...${}_{opt}$ )

attribute-using-prefix:
	using attribute-namespace :

attribute-list:
	attribute${}_{opt}$
	attribute-list , attribute${}_{opt}$
	attribute ...
	attribute-list , attribute ...

attribute:
	attribute-token attribute-argument-clause${}_{opt}$

attribute-token:
	identifier
	attribute-scoped-token

attribute-scoped-token:
	attribute-namespace :: identifier

attribute-namespace:
	identifier

attribute-argument-clause:
	( balanced-token-seq${}_{opt}$ )

balanced-token-seq:
	balanced-token
	balanced-token-seq balanced-token

balanced-token:
	( balanced-token-seq${}_{opt}$ )
	[ balanced-token-seq${}_{opt}$ ]
	{ balanced-token-seq${}_{opt}$ }
	any token other than a parenthesis, a bracket, or a brace

Если an attribute-specifier содержит attribute-using-prefix, attribute-listследующее, которое attribute-using-prefix не должно содержать, attribute-scoped-token и каждый attribute-tokenв, который attribute-list обрабатывается так, как если бы его identifierпрефикс был N​::​, где N - это attribute-namespace указанное в attribute-using-prefix. [  Note: Это правило не накладывает ограничений на то, как объект attribute-using-prefix влияет на токены в attribute-argument-clause. ] [ — end note  Example:

[[using CC: opt(1), debug]]         // same as [[CC​::​opt(1), CC​::​debug]]
  void f() {}
[[using CC: opt(1)]] [[CC::debug]]  // same as [[CC​::​opt(1)]] [[CC​::​debug]]
  void g() {}
[[using CC: CC::opt(1)]]            // error: cannot combine using and scoped attribute token
  void h() {}

 — end example ]

[  Note: Для каждого отдельного атрибута balanced-token-seqбудет указана форма . ]  — end note 

В attribute-listобъекте многоточие может отображаться только в том случае, если это attributeразрешено спецификацией. attributeС последующим многоточием является pack expansion. Не , attribute-specifierчто не содержит attributes не имеет никакого эффекта. Порядок, в котором attribute-tokens появляются символы attribute-list, не имеет значения. Если a keyword или an, alternative token которое удовлетворяет синтаксическим требованиям identifier, содержится в an attribute-token, это считается идентификатором. Нет name lookup не выполняется ни с одним из идентификаторов, содержащихся в файле attribute-token. attribute-tokenОпределяет дополнительные требования к attribute-argument-clause(если таковые имеются).

Каждый из них attribute-specifier-seqотносится appertain к некоторому объекту или утверждению, идентифицированному синтаксическим контекстом, в котором он встречается (пункт [stmt.stmt], пункт [dcl.dcl], пункт [dcl.decl]). Если attribute-specifier-seqэлемент, принадлежащий какой-либо сущности или оператору, содержит элемент attributeили, alignment-specifierкоторый не может применяться к этой сущности или оператору, программа сформирована неправильно. Если a attribute-specifier-seq принадлежит a friend declaration, это объявление должно быть определением. Нет attribute-specifier-seqне относится к explicit instantiation.

Для attribute-token (включая attribute-scoped-token), не указанного в этом международном стандарте, поведение определяется реализацией. Все, attribute-tokenчто не распознается реализацией, игнорируется. [  Note: Каждая реализация должна выбрать отличительное имя для attribute-namespaceфайла attribute-scoped-token. ] — end note 

Два последовательные левые квадратные маркеры скобки должны появляться только тогда , когда внедрив attribute-specifierили в пределах balanced-token-seqот attribute-argument-clause. [  Note: Если две последовательные левые квадратные скобки появляются там, где attribute-specifierнедопустимо, программа имеет неправильный формат, даже если скобки соответствуют альтернативной грамматической постановке. ] [  — end note  Example:

int p[10];
void f() {
  int x = 42, y[5];
  int(p[[x] { return x; }()]);  // error: invalid attribute on a nested declarator-id and
                                // not a function-style cast of an element of p.
  y[[] { return 2; }()] = 2;    // error even though attributes are not allowed in this context.
  int i [[vendor::attr([[]])]]; // well-formed implementation-defined attribute.
}

 — end example ]

alignment-specifier Может быть применена к переменной или к элементу данных класса, но оно не должно быть применено к битовое поле, параметр функции или exception-declaration([except.handle]). Также alignment-specifierможет применяться к объявлению или определению класса (в elaborated-type-specifierили class-head, соответственно) и к объявлению или определению перечисления (в opaque-enum-declarationили enum-head, соответственно ([dcl.enum])). alignment-specifierМноготочием является pack expansion.

Когда alignment-specifierимеет форму :alignas( constant-expression )

• (2.1)

  constant-expressionявляется неотъемлемой константным выражением

• (2.2)

  если постоянное выражение не оценивается как значение выравнивания ([basic.align]) или оценивается как расширенное выравнивание, а реализация не поддерживает это выравнивание в контексте объявления, программа имеет неправильный формат.

Элемент alignment-specifierформы имеет тот же эффект, что и ( ).alignas( type-id ) alignas(​alignof( type-id )) [expr.alignof]

Требование выравнивания объекта - это строжайшее ненулевое выравнивание, указанное в нем alignment-specifiers, если таковое имеется; в противном случае alignment-specifiers не действуют.

Комбинированный эффект all alignment-specifiers в объявлении не должен указывать менее строгое выравнивание, чем выравнивание, которое потребовалось бы для объявляемого объекта, если бы все, alignment-specifiers относящееся к этому объекту, было опущено. [ Example:

struct alignas(8) S {};
struct alignas(1) U {
  S s;
};  // error: U specifies an alignment that is less strict than if the alignas(1) were omitted.

 — end example ]

Если определяющее объявление объекта имеет alignment-specifier, любое не определяющее объявление этого объекта должно либо указывать эквивалентное выравнивание, либо не иметь alignment-specifier. И наоборот, если какое-либо объявление объекта имеет alignment-specifier, каждое определяющее объявление этого объекта должно указывать эквивалентное выравнивание. Диагностика не требуется, если объявления объекта имеют alignment-specifiers разные единицы перевода. [ Example:

// Translation unit #1:
struct S { int x; } s, *p = &s;

// Translation unit #2:
struct alignas(16) S;           // error: definition of S lacks alignment, no diagnostic required
extern S* p;

 — end example ]

[  Example: Выровненный буфер с требованием выравнивания A и содержащими N элементы типа T может быть объявлен как:

alignas(T) alignas(A) T buffer[N];

Указание alignas(T) гарантирует, что окончательное запрошенное выравнивание не будет слабее alignof(T), и, следовательно, программа не будет плохо сформирована. ] — end example 

[ Example:

alignas(double) void f();                           // error: alignment applied to function
alignas(double) unsigned char c[sizeof(double)];    // array of characters, suitably aligned for a double
extern unsigned char c[sizeof(double)];             // no alignas necessary
alignas(float)
  extern unsigned char c[sizeof(double)];           // error: different alignment in declaration

 — end example ]

attribute-token carries_­dependency Распространения определяет зависимость в и из функций. Он должен появляться не более одного раза в каждом attribute-listи не attribute-argument-clauseдолжен присутствовать. Атрибут может быть применен к declarator-ida parameter-declarationв объявлении функции или лямбда-выражении, и в этом случае он указывает инициализацию параметра carries a dependency для каждого lvalue-to-rvalue conversion из этих объектов. Атрибут также может применяться к declarator-idобъявлению функции, и в этом случае он указывает, что возвращаемое значение, если оно есть, несет зависимость от оценки выражения вызова функции.

Первое объявление функции должно указывать carries_­dependency атрибут для ее, declarator-idесли какое-либо объявление функции указывает carries_­dependency атрибут. Кроме того, первое объявление функции должно указывать carries_­dependency атрибут для параметра, если какое-либо объявление этой функции указывает carries_­dependency атрибут для этого параметра. Если функция или один из ее параметров объявлен с carries_­dependency атрибутом в своем первом объявлении в одной единице трансляции, а та же функция или один из ее параметров объявлен без carries_­dependency атрибута в своем первом объявлении в другой единице трансляции, программа имеет неправильный формат. , диагностика не требуется.

[ Атрибут не изменяет значение программы, но может привести к образованию более эффективного кода. ] Note: carries_­dependency  — end note 

[ Example:

/* Translation unit A. */

struct foo { int* a; int* b; };
std::atomic<struct foo *> foo_head[10];
int foo_array[10][10];

[[carries_dependency]] struct foo* f(int i) {
  return foo_head[i].load(memory_order_consume);
}

int g(int* x, int* y [[carries_dependency]]) {
  return kill_dependency(foo_array[*x][*y]);
}

/* Translation unit B. */

[[carries_dependency]] struct foo* f(int i);
int g(int* x, int* y [[carries_dependency]]);

int c = 3;

void h(int i) {
  struct foo* p;

  p = f(i);
  do_something_with(g(&c, p->a));
  do_something_with(g(p->a, &c));
}

carries_­dependency Атрибут функция f означает , что возвращаемое значение несет в себе зависимость из f, так что необходимость осуществления не ограничивает порядок после возвращения из f. Реализации f и вызывающая сторона могут выбрать сохранение зависимостей вместо выдачи инструкций по упорядочиванию аппаратной памяти (также известных как заборы).

Функция gвторой параметр «s имеет carries_­dependency атрибут, но его первый параметр не делает. Следовательно, hпервый вызов функции g несет зависимость g, а ее второй вызов - нет. Реализации может потребоваться вставить забор перед вторым вызовом g.

 — end example ]

attribute-token deprecated Могут быть использованы для имен меток и юридических лиц, использование которых по- прежнему допускается, но не рекомендуется для какой - то причине. [  Note: В частности, deprecated подходит для имен и организаций, которые считаются устаревшими или небезопасными. ] Он должен появляться не более одного раза в каждом . Может присутствовать и, если присутствует, то она должна иметь вид:  — end note attribute-listattribute-argument-clause

( string-literal )

[ В может быть использовано для объяснения обоснования устаревания и / или предложить заменяющий объект. ] Note: string-literalattribute-argument-clause — end note 

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

Имя или сущность, объявленные без deprecated атрибута, позже могут быть повторно объявлены с помощью атрибута и наоборот. [  Note: Таким образом, объект, изначально объявленный без атрибута, может быть помечен как устаревший при последующем повторном объявлении. Однако после того, как объект помечен как устаревший, последующие повторные объявления не отменяют его. ] Допускаются повторные объявления с использованием разных форм атрибута (с или без или с разными ).  — end note attribute-argument-clauseattribute-argument-clauses

[  Note: Реализации могут использовать deprecated атрибут для создания диагностического сообщения в случае, если программа обращается к имени или объекту, отличному от его объявления, после объявления, которое определяет атрибут. Диагностическое сообщение может включать в себя текст attribute-argument-clauseлюбого deprecated атрибута, применяемого к имени или объекту. ]  — end note 

attribute-token fallthrough Может быть применен к null statement; такое заявление - провальное заявление. Они attribute-token fallthrough должны появляться не более одного раза в каждом attribute-listи не attribute-argument-clauseдолжны присутствовать. Заявление о провале может появиться только внутри вложенного switch statement. Следующим оператором, который будет выполняться после оператора перехода, должен быть помеченный оператор, метка которого является меткой case или меткой по умолчанию для того же switch оператора. Программа плохо сформирована, если такого оператора нет.

[  Note: Использование оператора fallthrough предназначено для подавления предупреждения, которое реализация могла бы в противном случае выдать для случая или метки по умолчанию, доступной из другого случая или метки по умолчанию на некотором пути выполнения. Реализациям рекомендуется выдавать предупреждение, если оператор сбоя недоступен динамически. ] — end note 

[ Example:

void f(int n) {
  void g(), h(), i();
  switch (n) {
  case 1:
  case 2:
    g();
    [[fallthrough]];
  case 3:                       // warning on fallthrough discouraged
    h();
  case 4:                       // implementation may warn on fallthrough
    i();
    [[fallthrough]];            // ill-formed
  }
}

 — end example ]

Значок attribute-token maybe_­unused указывает на то, что имя или объект, возможно, намеренно не используются. Он должен появляться не более одного раза в каждом attribute-listи не attribute-argument-clauseдолжен присутствовать.

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

[  Note: Для отмеченного объекта maybe_­unusedрекомендуется, чтобы реализации не выдавали предупреждения о том, что объект не используется или что объект используется, несмотря на наличие атрибута. ] — end note 

Имя или сущность, объявленные без maybe_­unused атрибута, позже могут быть повторно объявлены с атрибутом и наоборот. Сущность считается отмеченной после первого объявления, которое ее отмечает.

[ Example:

[[maybe_unused]] void f([[maybe_unused]] bool thing1,
                        [[maybe_unused]] bool thing2) {
  [[maybe_unused]] bool b = thing1 && thing2;
  assert(b);
}

Реализациям рекомендуется не предупреждать о том, что b не используется, независимо от того, определено оно или нет NDEBUG . ] — end example 

attribute-token nodiscard Может быть применен к declarator-id в объявлении функции или к объявлению класса или перечисления. Он должен появляться не более одного раза в каждом attribute-listи не attribute-argument-clauseдолжен присутствовать.

[  Note: Вызов nodiscard - это выражение вызова функции, которое вызывает ранее объявленную функцию nodiscardили возвращаемый тип которой, возможно, является классом с квалификацией cv или отмеченным типом перечисления nodiscard. Появление вызова nodiscard как потенциально оцененного выражения отбрасываемого значения (пункт [expr]) не приветствуется, если явно не приведено к void. Реализациям рекомендуется выдавать предупреждение в таких случаях. Обычно это происходит из-за того, что отказ от возвращаемого значения вызова nodiscard имеет неожиданные последствия. ] — end note 

[ Example:

struct [[nodiscard]] error_info { /* ... */ };
error_info enable_missile_safety_mode();
void launch_missiles();
void test_missiles() {
  enable_missile_safety_mode(); // warning encouraged
  launch_missiles();
}
error_info &foo();
void f() { foo(); }             // warning not encouraged: not a nodiscard call, because neither
                                // the (reference) return type nor the function is declared nodiscard

 — end example ]

В attribute-token noreturn указывает , что функция не возвращает. Он должен появляться не более одного раза в каждом attribute-listи не attribute-argument-clauseдолжен присутствовать. Атрибут может быть применен к declarator-idв объявлении функции. Первое объявление функции должно указывать noreturn атрибут, если какое-либо объявление этой функции указывает noreturn атрибут. Если функция объявляется с noreturn атрибутом в одной единице трансляции, а та же функция объявляется без noreturn атрибута в другой единице трансляции, программа имеет неправильный формат и диагностика не требуется.

Если функция f вызывается там, где f ранее была объявлена ​​с noreturn атрибутом, и в f конечном итоге возвращается, поведение не определено. [  Note: Функция может завершиться выдачей исключения. ] [ Реализациям рекомендуется выдавать предупреждение, если отмеченная функция может вернуться. ]  — end note  Note: [[noreturn]]  — end note 

[ Example:

[[ noreturn ]] void f() {
  throw "error";                // OK
}

[[ noreturn ]] void q(int i) {  // behavior is undefined if called with an argument <= 0
  if (i > 0)
    throw "positive";
}

 — end example ]