6 Basic concepts [basic]

Каждое имя вводится в некоторой части текста программы, называемой a , которая является самой большой частью программы, в которой это имя , то есть в которой это имя может использоваться как неквалифицированное имя для ссылки на один и тот же объект. В общем, каждое конкретное имя допустимо только в пределах некоторой, возможно, несмежной части текста программы, называемой его . Чтобы определить объем объявления, иногда удобно обратиться к объекту объявления. Область действия объявления такая же, как и ее потенциальная область, если только потенциальная область не содержит другое объявление с тем же именем. В этом случае потенциальная область действия объявления во внутренней (содержащейся) декларативной области исключается из области действия объявления во внешней (содержащей) декларативной области.declarative region valid scopepotential scope

[  Example: В

int j = 24;
int main() {
  int i = j, j;
  j = 42;
}

идентификатор j объявляется дважды как имя (и используется дважды). Декларативная область первого j включает весь пример. Потенциальная область действия первого j начинается сразу после этого j и продолжается до конца программы, но ее (фактическая) область действия исключает текст между символами , и }. Декларативная область второго объявления j ( j непосредственно перед точкой с запятой) включает весь текст между { и }, но его потенциальная область исключает объявление i. Область действия второго объявления j совпадает с его потенциальной областью. ] — end example 

Имена, объявленные объявлением, вводятся в область видимости, в которой происходит объявление, за исключением того, что наличие a friend specifier, некоторые виды использования elaborated-type-specifierи using-directives изменяют это общее поведение.

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

• (4.1)

  все они должны относиться к одному и тому же объекту или все относиться к функциям и шаблонам функций; или

• (4.2)

  ровно одно объявление должно объявлять имя класса или имя перечисления, которое не является именем typedef, а все другие объявления должны ссылаться на одну и ту же переменную, нестатический член данных или перечислитель, или все они относятся к функциям и шаблонам функций; в этом случае имя класса или имя перечисления hidden. [  Note: Имя пространства имен или имя шаблона класса должно быть уникальным в своей декларативной области ([namespace.alias], пункт [temp]). ]  — end note 

[  Note: Эти ограничения применяются к декларативной области, в которой вводится имя, которая не обязательно совпадает с областью, в которой происходит объявление. В частности, elaborated-type-specifiers и friend declarations может ввести (возможно, невидимое) имя во включающее пространство имен; эти ограничения распространяются на этот регион. Локальные объявления extern ([basic.link]) могут вводить имя в декларативную область, где появляется объявление, а также вводить (возможно, не видимое) имя во включающее пространство имен; эти ограничения распространяются на оба региона. ]  — end note 

[  Note: Правила поиска имени кратко изложены в [basic.lookup]. ] — end note 

Для point of declaration имени ставится сразу после его завершения declarator и перед initializer(если есть), за исключением случаев, указанных ниже. [ Example:

unsigned char x = 12;
{ unsigned char x = x; }

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

[ Имя из внешней области видимости остается видимым до момента объявления имени, которое его скрывает. [ Note:  Example:

const int  i = 2;
{ int  i[i]; }

объявляет массив из двух целых чисел в области видимости блока. ] ]  — end example   — end note 

Точка объявления для класса или шаблона класса, сначала объявленного a, class-specifierнаходится сразу после identifierили simple-template-id(если есть) в его class-head. Точка объявления для перечисления находится сразу после identifier(если есть) либо в его, enum-specifierлибо в его первом opaque-enum-declaration, в зависимости от того, что наступит раньше. Точка объявления псевдонима или шаблона псевдонима следует сразу за тем, type-idна который ссылается псевдоним.

Точка объявления using-declarator, которая не называет конструктор, находится сразу после using-declarator.

Точка объявления перечислителя находится сразу после его enumerator-definition. [ Example:

const int x = 12;
{ enum { x = x }; }

Здесь перечислитель x инициализируется значением константы x, а именно 12. ]  — end example 

После точки объявления члена класса имя члена можно искать в области его класса. [ Это верно, даже если класс является неполным. Например, Note:

struct X {
  enum E { z = 16 };
  int b[X::z];      // OK
};

 — end note ]

Точка объявления класса, впервые объявленного в файле, elaborated-type-specifierвыглядит следующим образом:

• (7.1)

  для объявления формы

  class-key attribute-specifier-seq${}_{opt}$ identifier ;
  

  identifierобъявляется быть class-nameв объеме , который содержит объявление, в противном случае

• (7.2)

  для elaborated-type-specifierформы

  class-key identifier
  

  если elaborated-type-specifierиспользуется в decl-specifier-seqили parameter-declaration-clause функции, определенной в области пространства имен, identifierобъявляется как class-nameв пространстве имен, содержащем объявление; в противном случае, за исключением объявления друга, объект identifierобъявляется в наименьшем пространстве имен или области блока, который содержит объявление. [  Note: Эти правила также применяются в шаблонах. ] [ Другие формы не объявляют новое имя и, следовательно, должны ссылаться на существующее . Смотрите и . ]  — end note  Note: elaborated-type-specifiertype-name [basic.lookup.elab] [dcl.type.elab]  — end note 

Точка объявления для an injected-class-name следует сразу за открывающей скобкой определения класса.

Точка объявления для локальной предопределенной переменной ([dcl.fct.def]) находится непосредственно перед function-bodyопределением функции.

Точка объявления параметра шаблона - сразу после его завершения template-parameter. [ Example:

typedef unsigned char T;
template<class T
  = T     // lookup finds the typedef name of unsigned char
  , T     // lookup finds the template parameter
    N = 0> struct A { };

 — end example ]

[  Note: Дружественные объявления относятся к функциям или классам, которые являются членами ближайшего включающего пространства имен, но они не вводят новые имена в это пространство имен ([namespace.memdef]). Объявления функций в области видимости блока и объявления переменных со extern спецификатором в области видимости блока относятся к объявлениям, которые являются членами включающего пространства имен, но они не вводят новые имена в эту область. ] — end note 

[  Note: Для создания экземпляра шаблона см [temp.point].. ] — end note 

Имя, объявленное в a, block является локальным для этого блока; это есть block scope. Его потенциальная область действия начинается с его point of declaration и заканчивается в конце его блока. Переменная, объявленная в области видимости блока, - это local variable.

Потенциальная область видимости имени параметра функции (включая имя, появляющееся в a lambda-declarator) или предопределенной переменной функции в a function definition начинается с точки ее объявления. Если функция имеет function-try-blockпотенциальную область видимости параметра или предопределенной переменной, локальной для функции, заканчивается в конце последнего связанного обработчика, в противном случае она заканчивается в конце самого внешнего блока определения функции. Имя параметра не должно повторно объявляться ни во внешнем блоке определения функции, ни во внешнем блоке любого обработчика, связанного с a function-try-block.

Имя, объявленное в объекте, exception-declaration является локальным по отношению к handlerобъекту, и его нельзя повторно объявлять во внешнем блоке handler.

Имена объявлены в init-statement, то for-range-declarationи в conditionиз if, while, for, и switch заявления являются локальными к if, while, forили switch заявление ( в том числе и контролируемое заявление), и не может быть повторно объявлен в последующем состоянии этого заявления , ни в наружном блоке ( или, для if оператора, любой из самых внешних блоков) контролируемого оператора; см [stmt.select].

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

Labels имеют function scope и могут использоваться в любом месте функции, в которой они объявлены. Только ярлыки имеют область действия.

Декларативная область - namespace-definitionэто его namespace-body. Объекты, объявленные в a, namespace-bodyназываются members принадлежащими пространству имен, а имена, введенные этими объявлениями в декларативную область пространства имен, называются member names принадлежащими пространству имен. Имя члена пространства имен имеет область пространства имен. Его потенциальная область действия включает пространство имен, начиная с имени point of declaration ; и для каждого, using-directiveкоторый назначает пространство имен члена, потенциальная область действия члена включает ту часть потенциальной области видимости, using-directiveкоторая следует за точкой объявления члена. [ Example:

namespace N {
  int i;
  int g(int a) { return a; }
  int j();
  void q();
}
namespace { int l=1; }
// the potential scope of l is from its point of declaration to the end of the translation unit

namespace N {
  int g(char a) {   // overloads N​::​g(int)
    return l+a;     // l is from unnamed namespace
  }

  int i;            // error: duplicate definition
  int j();          // OK: duplicate function declaration

  int j() {         // OK: definition of N​::​j()
    return g(i);    // calls N​::​g(int)
  }
  int q();          // error: different return type
}

 — end example ]

На член пространства имен также можно ссылаться после того, как ​::​ оператор разрешения области видимости ([expr.prim]) применен к имени его пространства имен или имени пространства имен, которое назначает пространство имен члена в using-directive; см [namespace.qual].

Самая внешняя декларативная область единицы перевода - это также пространство имен, называемое global namespace. Имя, объявленное в глобальном пространстве имен, имеет global namespace scope (также называется global scope). Потенциальная область видимости такого имени начинается point of declaration и заканчивается в конце единицы трансляции, которая является ее декларативной областью. Имя с глобальной областью пространства имен называется global name.

Потенциальная область видимости имени, объявленного в классе, состоит не только из декларативной области, следующей за точкой объявления имени, но также из всех тел функций, аргументов по умолчанию noexcept-specifiersи brace-or-equal-initializers нестатических элементов данных в этом классе (включая такие вещи в вложенные классы).

Имя, N используемое в классе, S должно ссылаться на одно и то же объявление в его контексте и при повторной оценке в завершенной области S. Нарушение этого правила не требует диагностики.

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

Потенциальная область действия объявления, которая простирается до конца определения класса или за его пределами, также распространяется на области, определенные определениями его членов, даже если члены определены лексически вне класса (это включает определения статических элементов данных, определения вложенных классов, и определения функций-членов, включая тело функции-члена и любую часть декларативной части таких определений, которая следует за declarator-id, включая a parameter-declaration-clauseи any default arguments).

[ Example:

typedef int  c;
enum { i = 1 };

class X {
  char  v[i];                       // error: i refers to ​::​i but when reevaluated is X​::​i
  int  f() { return sizeof(c); }    // OK: X​::​c
  char  c;
  enum { i = 2 };
};

typedef char*  T;
struct Y {
  T  a;                             // error: T refers to ​::​T but when reevaluated is Y​::​T
  typedef long  T;
  T  b;
};

typedef int I;
class D {
  typedef I I;                      // error, even though no reordering involved
};

 — end example ]

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

• (6.1)

  в рамках своего класса (как описано выше) или класса derived из своего класса,

• (6.2)

  после . применения оператора к выражению типа его класса ([expr.ref]) или класса, производного от его класса,

• (6.3)

  после -> применения оператора к указателю на объект его класса ([expr.ref]) или класса, производного от его класса,

• (6.4)

  после того, как ​::​ оператор разрешения области видимости ([expr.prim]) применен к имени его класса или класса, производного от его класса.

Имя scoped enumerator имеет enumeration scope. Его потенциальная область действия начинается в точке объявления и заканчивается в конце enum-specifier.

Декларативная область имени параметра шаблона шаблона template-parameter- наименьшая, template-parameter-list в которой имя было введено.

Декларативная область имени параметра шаблона шаблона - наименьшая, template-declarationв которой имя было введено. К этой декларативной области принадлежат только имена параметров шаблона; любой другой вид имени, введенный с помощью declarationa template-declaration, вместо этого вводится в ту же декларативную область, где он был бы введен в результате нешаблонного объявления с тем же именем. [ Example:

namespace N {
  template<class T> struct A { };               // #1
  template<class U> void f(U) { }               // #2
  struct B {
    template<class V> friend int g(struct C*);  // #3
  };
}

Декларативная область T, U и V являются template-declarations по линиям # 1, # 2 и # 3, соответственно. Но имена A, f, g и C все они принадлежат к одной и той же декларативной области , а именно - namespace-bodyиз N. (g по-прежнему считается принадлежащей этой декларативной области, несмотря на то, что она была скрыта во время поиска квалифицированного и неквалифицированного имени.) ] — end example 

Потенциальная область действия имени параметра шаблона начинается с его point of declaration и заканчивается в конце его декларативной области. [  Note: Это означает, что a template-parameterможет использоваться в объявлении последующих template-parameters аргументов и их аргументов по умолчанию, но не может использоваться в предшествующих template-parameters аргументах или их аргументах по умолчанию. Например,

template<class T, T* p, class U = T> class X { /* ... */ };
template<class T> void f(T* p = new T);

Это также означает, что a template-parameterможет использоваться в спецификации базовых классов. Например,

template<class T> class X : public Array<T> { /* ... */ };
template<class T> class Y : public T { /* ... */ };

Использование параметра шаблона в качестве базового класса подразумевает, что класс, используемый в качестве аргумента шаблона, должен быть определен, а не просто объявлен при создании экземпляра шаблона класса. ] — end note 

Декларативная область имени параметра шаблона вложена в непосредственно включающую декларативную область. [  Note: В результате template-parameter hides любой объект с тем же именем во включающей области. [ Example:

typedef int N;
template<N X, typename N, template<N Y> class T> struct A;

Здесь, X является параметром шаблона не-типа типа int и Y является параметром шаблона не-типа того же типа в качестве второго параметра шаблона из A. ] ]  — end example   — end note 

[  Note: Поскольку имя параметра шаблона не может быть повторно объявлено в пределах его потенциальной области ([temp.local]), область действия параметра шаблона часто является его потенциальной областью. Однако имя параметра шаблона все еще можно скрыть; см [temp.local]. ]  — end note 

Имя может быть скрыто явным объявлением того же имени во вложенной декларативной области или производном классе ([class.member.lookup]).

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

В определении функции-члена объявление имени в области видимости блока скрывает объявление члена класса с тем же именем; см [basic.scope.class]. Объявление члена в a derived class скрывает объявление члена одноименного базового класса; см [class.member.lookup].

Во время поиска имени, уточненного именем пространства имен, объявления, которые в противном случае стали бы видимыми с помощью a, using-directiveмогут быть скрыты объявлениями с тем же именем в пространстве имен, содержащем using-directive; см [namespace.qual].

Если имя находится в области видимости и не скрыто, оно считается скрытым visible.

Во всех случаях, перечисленных в [basic.lookup.unqual], области действия ищутся для объявления в порядке, указанном в каждой из соответствующих категорий; Поиск имени заканчивается, как только для имени найдено объявление. Если объявление не найдено, программа имеет неправильный формат.

Объявления из пространства имен, обозначенного символом a, using-directiveстановятся видимыми в пространстве имен, содержащем using-directive; см [namespace.udir]. Для целей правил поиска неквалифицированных имен, описанных в [basic.lookup.unqual], объявления из пространства имен, назначенного using-directiveэлементом, считаются членами этого включающего пространства имен.

Поиск неполного имени, используемого в postfix-expressionкачестве вызова функции, описан в [basic.lookup.argdep]. [  Note: Для определения (во время синтаксического анализа), является ли выражение postfix-expressionдля вызова функции, применяются обычные правила поиска имени. Правила [basic.lookup.argdep] не влияют на синтаксическую интерпретацию выражения. Например,

typedef int f;
namespace N {
  struct A {
    friend void f(A &);
    operator int();
    void g(A a) {
      int i = f(a);  // f is the typedef, not the friend function: equivalent to int(a)
    }
  };
}

Поскольку выражение не является вызовом функции, argument-dependent name lookup не применяется и функция друга f не найдена. ]  — end note 

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

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

В определении функции, которая является членом пространства имен N, имя, используемое после функции, declarator-id29 должно быть объявлено до его использования в блоке, в котором оно используется, или в одном из его включающих блоков ([stmt.block]), или должно быть объявлено перед его использованием в пространство имен N или, если N это вложенное пространство имен, должно быть объявлено перед его использованием в одном из Nвключающих пространств имен. [ Example:

namespace A {
  namespace N {
    void f();
  }
}
void A::N::f() {
  i = 5;
  // The following scopes are searched for a declaration of i:
  // 1) outermost block scope of A​::​N​::​f, before the use of i
  // 2) scope of namespace N
  // 3) scope of namespace A
  // 4) global scope, before the definition of A​::​N​::​f
}

 — end example ]

Имя , используемое в определении класса X внешней функции члена тела, аргумент по умолчанию, noexcept-specifier, brace-or-equal-initializerиз нестатического элемента данных или определения вложенного класса ,30 должны быть объявлен в одном из следующих способов:

• (7.1)

  перед его использованием в классе X или быть членом базового класса X ([class.member.lookup]), или

• (7.2)

  if X является a nested class of class Y, до определения X in Y, или должен быть членом базового класса Y (этот поиск применяется, в свою очередь, к Yохватывающим классам, начиная с самого внутреннего включающего класса),31 или

• (7.3)

  если X является local class или является вложенным классом локального класса, перед определением класса X в блоке, включающем определение класса X, или

• (7.4)

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

[ Example:

namespace M {
  class B { };
}

namespace N {
  class Y : public M::B {
    class X {
      int a[i];
    };
  };
}

// The following scopes are searched for a declaration of i:
// 1) scope of class N​::​Y​::​X, before the use of i
// 2) scope of class N​::​Y, before the definition of N​::​Y​::​X
// 3) scope of N​::​Y's base class M​::​B
// 4) scope of namespace N, before the definition of N​::​Y
// 5) global scope, before the definition of N

 — end example ] [  Note: При поиске предыдущего объявления класса или функции, введенного friend объявлением, области за пределами самой внутренней области охватывающего пространства имен не рассматриваются; см [namespace.memdef]. ] [ далее описывает ограничения на использование имен в определении класса. далее описывает ограничения на использование имен в определениях вложенных классов. далее описывает ограничения на использование имен в определениях локальных классов. ]  — end note  Note: [basic.scope.class] [class.nest] [class.local]  — end note 

Для членов класса должно быть объявлено Xимя, используемое в теле функции-члена, в аргументе по умолчанию, в a noexcept-specifier, в brace-or-equal-initializera non-static data memberили в определении члена класса вне определения X, следующее за членом. declarator-id32одним из следующих способов:

• (8.1)

  перед его использованием в блоке, в котором он используется, или во включающем блоке ([stmt.block]), или

• (8.2)

  должен быть членом класса X или быть членом базового класса X ([class.member.lookup]), или

• (8.3)

  if X является nested class классом Y, должен быть членом Yили должен быть членом базового класса Y (этот поиск применяется, в свою очередь, к Yвключающим классам, начиная с самого внутреннего включающего класса),33 или

• (8.4)

  если X является local class или является вложенным классом локального класса, перед определением класса X в блоке, включающем определение класса X, или

• (8.5)

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

[ Example:

class B { };
namespace M {
  namespace N {
    class X : public B {
      void f();
    };
  }
}
void M::N::X::f() {
  i = 16;
}

// The following scopes are searched for a declaration of i:
// 1) outermost block scope of M​::​N​::​X​::​f, before the use of i
// 2) scope of class M​::​N​::​X
// 3) scope of M​::​N​::​X's base class B
// 4) scope of namespace M​::​N
// 5) scope of namespace M
// 6) global scope, before the definition of M​::​N​::​X​::​f

 — end example ] [  Note: [class.mfct] и [class.static] далее опишите ограничения на использование имен в определениях функций-членов. [class.nest] далее описывает ограничения на использование имен в рамках вложенных классов. [class.local] далее описывает ограничения на использование имен в определениях локальных классов. ]  — end note 

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

В friend объявлении, называющем функцию-член, имя, используемое в деклараторе функции, а не часть a template-argument в, declarator-idсначала ищется в области действия class ([class.member.lookup]) функции-члена . Если он не найден или если имя является частью a template-argumentв declarator-id, поиск выполняется так, как описано для неквалифицированных имен в определении класса, предоставляющего дружбу. [ Example:

struct A {
  typedef int AT;
  void f1(AT);
  void f2(float);
  template <class T> void f3();
};
struct B {
  typedef char AT;
  typedef float BT;
  friend void A::f1(AT);      // parameter type is A​::​AT
  friend void A::f2(BT);      // parameter type is B​::​BT
  friend void A::f3<AT>();    // template argument is B​::​AT
};

 — end example ]

Во время поиска имени, используемого в качестве default argument в функции parameter-declaration-clauseили используемого в expressionэлементе mem-initializerдля конструктора ([class.base.init]), имена параметров функции видны и скрывают имена сущностей, объявленных в областях блока, класса или пространства имен, содержащих объявление функции. [  Note: [dcl.fct.default] далее описывает ограничения на использование имен в аргументах по умолчанию. [class.base.init] далее описывает ограничения на использование имен в ctor-initializer. ] — end note 

Во время поиска имени, используемого в constant-expressionобъекте enumerator-definition, ранее объявленные enumerators в перечислении становятся видимыми и скрывают имена сущностей, объявленных в областях блока, класса или пространства имен, содержащих enum-specifier.

Имя, используемое в определении static data member класса X (после qualified-id статического члена) ищется, как если бы имя использовалось в функции-члене класса X. [  Note: [class.static.data] далее описывает ограничения на использование имен в определении элемента static данных. ]  — end note 

Если переменный член пространства имен определен вне области его пространства имен, то любое имя, которое появляется в определении члена (после declarator-id), ищется так, как если бы определение члена произошло в его пространстве имен. [ Example:

namespace N {
  int i = 4;
  extern int j;
}

int i = 2;

int N::j = i;       // N​::​j == 4

 — end example ]

Имя, используемое в обработчике для a function-try-block, ищется так, как если бы имя использовалось во внешнем блоке определения функции. В частности, имена параметров функции не должны повторно объявляться exception-declarationни в самом внешнем блоке обработчика, ни в самом внешнем блоке обработчика function-try-block. Имена, объявленные во внешнем блоке определения функции, не обнаруживаются при поиске в области обработчика для function-try-block. [  Note: Но имена параметров функции найдены. ]  — end note 

[  Note: Правила поиска имени в определениях шаблонов описаны в [temp.res]. ]  — end note 

Когда postfix-expressionin a function call является an unqualified-id, unqualified lookup могут быть найдены другие пространства имен, не рассматриваемые в обычном режиме , и в этих пространствах имен могут быть найдены дружественные функции области пространства имен или объявления шаблонов функций ([class.friend]), которые иным образом не видны. Эти изменения в поиске зависят от типов аргументов (а для аргументов шаблона шаблона - пространства имен аргумента шаблона). [ Example:

namespace N {
  struct S { };
  void f(S);
}

void g() {
  N::S s;
  f(s);     // OK: calls N​::​f
  (f)(s);   // error: N​::​f not considered; parentheses prevent argument-dependent lookup
}

 — end example ]

Для каждого типа аргумента T в вызове функции существует набор из нуля или более associated namespaces и набор из нуля или более, associated classes которые следует учитывать. Наборы пространств имен и классов полностью определяются типами аргументов функции (и пространством имен любого аргумента шаблона шаблона). Имена Typedef, using-declarations используемые для указания типов, не участвуют в этом наборе. Наборы пространств имен и классов определяются следующим образом:

• (2.1)

  Если T это фундаментальный тип, связанные с ним наборы пространств имен и классов пусты.

• (2.2)

  Если T это тип класса (включая объединения), то связанные с ним классы: сам класс; класс, членом которого он является, если таковой имеется; и его прямые и косвенные базовые классы. Связанные с ним пространства имен - это самые внутренние включающие пространства имен связанных с ним классов. Кроме того, если T это специализация шаблона класса, связанные с ней пространства имен и классы также включают: пространства имен и классы, связанные с типами аргументов шаблона, предоставленными для параметров типа шаблона (исключая параметры шаблона шаблона); пространства имен, членами которых являются любые аргументы шаблона шаблона; и классы, членами которых являются любые шаблоны-элементы, используемые в качестве аргументов шаблона шаблона. [  Note: Аргументы шаблона, не являющиеся типом, не влияют на набор связанных пространств имен. ] — end note 

• (2.3)

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

• (2.4)

  Если T это указатель U или массив U, связанные с ним пространства имен и классы - это те, с которыми связаны U.

• (2.5)

  Если T это тип функции, связанные с ним пространства имен и классы - это те, которые связаны с типами параметров функции и те, которые связаны с типом возвращаемого значения.

• (2.6)

  Если T это указатель на функцию-член класса X, связанные с ним пространства имен и классы - это те, которые связаны с типами параметров функции и типом возвращаемого значения, вместе с теми, которые связаны с X.

• (2.7)

  Если T это указатель на член данных класса X, связанные с ним пространства имен и классы - это те, которые связаны с типом члена вместе с теми, которые связаны с X.

Если связанное пространство имен - это inline namespaceпространство имен, в которое оно входит, также включается в набор. Если связанное пространство имен непосредственно содержит встроенные пространства имен, эти встроенные пространства имен также включаются в набор. Кроме того, если аргумент является именем или адресом набора перегруженных функций и / или шаблонов функций, связанные с ним классы и пространства имен представляют собой объединение классов и пространств имен, связанных с каждым из членов набора, т. Е. Связанных классов и пространств имен. с типами параметров и возвращаемым типом. Кроме того, если вышеупомянутый набор перегруженных функций назван с template-id, связанные с ним классы и пространства имен также включают классы и пространства имен этого типа template-arguments и его шаблона template-arguments.

Пусть X будет набором поиска, созданным, unqualified lookup и пусть Y будет набором поиска, созданным поиском, зависимым от аргументов (определенным следующим образом). Если X содержит

• (3.1)

  объявление члена класса или

• (3.2)

  объявление функции блочной области, которое не является using-declaration, или

• (3.3)

  объявление, которое не является ни функцией, ни шаблоном функции

то Y пусто. В противном случае Y набор объявлений находится в пространствах имен, связанных с типами аргументов, как описано ниже. Набор объявлений, найденный при поиске имени, представляет собой объединение X и Y. [  Note: Пространства имен и классы, связанные с типами аргументов, могут включать пространства имен и классы, уже учтенные обычным неквалифицированным поиском. ] [  — end note  Example:

namespace NS {
  class T { };
  void f(T);
  void g(T, int);
}
NS::T parm;
void g(NS::T, float);
int main() {
  f(parm);                      // OK: calls NS​::​f
  extern void g(NS::T, float);
  g(parm, 1);                   // OK: calls g(NS​::​T, float)
}

 — end example ]

При рассмотрении связанного пространства имен поиск такой же, как поиск, выполняемый, когда связанное пространство имен используется в качестве квалификатора ([namespace.qual]), за исключением того, что:

• (4.1)

  Любые using-directives элементы в связанном пространстве имен игнорируются.

• (4.2)

  Любые дружественные функции в области видимости пространства имен или шаблоны дружественных функций, объявленные в связанных классах, видны в их соответствующих пространствах имен, даже если они не видны во время обычного поиска ([class.friend]).

• (4.3)

  Все имена, кроме (возможно, перегруженных) функций и шаблонов функций, игнорируются.

На имя класса или члена пространства имен или перечислителя можно ссылаться после ​::​ применения оператора разрешения области ([expr.prim]) к объекту, nested-name-specifierкоторый обозначает его класс, пространство имен или перечисление. Если перед ​::​ оператором разрешения области в a nested-name-specifierне стоит decltype-specifier, поиск предшествующего имени ​::​ учитывает только пространства имен, типы и шаблоны, специализацией которых являются типы. Если найденное имя не обозначает пространство имен или класс, перечисление или зависимый тип, программа имеет неправильный формат. [ Example:

class A {
public:
  static int n;
};
int main() {
  int A;
  A::n = 42;        // OK
  A b;              // ill-formed: A does not name a type
}

 — end example ]

[  Note: Множественные уточненные имена, например,, N1​::​N2​::​N3​::​nмогут использоваться для обозначения членов вложенных классов ([class.nest]) или членов вложенных пространств имен. ]  — end note 

В объявлении, в котором declarator-idесть a qualified-id, имена, использованные до qualified-id объявления, ищутся в определяющей области пространства имен; имена, следующие за qualified-id, ищутся в области класса или пространства имен члена. [ Example:

class X { };
class C {
  class X { };
  static const int number = 50;
  static X arr[number];
};
X C::arr[number];   // ill-formed:
                    // equivalent to ​::​X C​::​arr[C​::​number];
                    // and not to C​::​X C​::​arr[C​::​number];

 — end example ]

Имя с префиксом унарного оператора области видимости ​::​ ([expr.prim]) ищется в глобальной области видимости в той единице перевода, в которой оно используется. Имя должно быть объявлено в области глобального пространства имен или должно быть именем, объявление которого видно в глобальной области видимости из-за using-directive([namespace.qual]). Использование ​::​ позволяет ссылаться на глобальное имя, даже если его идентификатор был hidden.

Имя с префиксом a nested-name-specifier, обозначающее тип перечисления, должно представлять собой элемент enumerator этого перечисления.

Если a pseudo-destructor-name([expr.pseudo]) содержит a nested-name-specifier, type-names ищутся типы в области, обозначенной nested-name-specifier. Аналогично в qualified-idформе:

nested-name-specifier${}_{opt}$ class-name :: ~ class-name

второй class-nameищется в той же области, что и первый. [ Example:

struct C {
  typedef int I;
};
typedef int I1, I2;
extern int* p;
extern int* q;
p->C::I::~I();      // I is looked up in the scope of C
q->I1::~I2();       // I2 is looked up in the scope of the postfix-expression

struct A {
  ~A();
};
typedef A AB;
int main() {
  AB* p;
  p->AB::~AB();     // explicitly calls the destructor for A
}

 — end example ] [  Note: [basic.lookup.classref] Описывает , как имя подстановки после того , как протекает . и -> операторов. ]  — end note 

elaborated-type-specifierМожет быть использовано для обозначения предварительно объявленных class-nameили enum-nameхотя имя было hidden в заявлении не-типа.

Если elaborated-type-specifierнет nested-name-specifier, и если он не elaborated-type-specifierуказан в декларации следующей формы:

class-key attribute-specifier-seq${}_{opt}$ identifier ;

identifierищется в соответствии [basic.lookup.unqual] но игнорируя любые имена не типа , которые были объявлены. Если elaborated-type-specifierвводится enum ключевым словом, и этот поиск не находит ранее объявленного type-name, то elaborated-type-specifier это неправильно сформировано. Если elaborated-type-specifierвводится с помощью, class-keyи этот поиск не находит ранее объявленного type-name, или если elaborated-type-specifierпоявляется в объявлении с формой:

class-key attribute-specifier-seq${}_{opt}$ identifier ;

elaborated-type-specifierявляется свидетельством того, что вводит , class-nameкак описано в [basic.scope.pdecl].

Если elaborated-type-specifierесть nested-name-specifier, выполняется поиск квалифицированного имени, как описано в разделе [basic.lookup.qual], но игнорируя любые объявленные не-типовые имена. Если поиск по имени не находит ранее объявленного type-name, elaborated-type-specifier значит, неправильно сформирован. [ Example:

struct Node {
  struct Node* Next;            // OK: Refers to Node at global scope
  struct Data* Data;            // OK: Declares type Data
                                // at global scope and member Data
};

struct Data {
  struct Node* Node;            // OK: Refers to Node at global scope
  friend struct ::Glob;         // error: Glob is not declared, cannot introduce a qualified type ([dcl.type.elab])
  friend struct Glob;           // OK: Refers to (as yet) undeclared Glob at global scope.
  /* ... */
};

struct Base {
  struct Data;                  // OK: Declares nested Data
  struct ::Data*     thatData;  // OK: Refers to ​::​Data
  struct Base::Data* thisData;  // OK: Refers to nested Data
  friend class ::Data;          // OK: global Data is a friend
  friend class Data;            // OK: nested Data is a friend
  struct Data { /* ... */ };    // Defines nested Data
};

struct Data;                    // OK: Redeclares Data at global scope
struct ::Data;                  // error: cannot introduce a qualified type ([dcl.type.elab])
struct Base::Data;              // error: cannot introduce a qualified type ([dcl.type.elab])
struct Base::Datum;             // error: Datum undefined
struct Base::Data* pBase;       // OK: refers to nested Data

 — end example ]

В class member access выражении, если за токеном . или -> сразу следует символ, за которым identifier следует символ <, необходимо найти идентификатор, чтобы определить, < является ли это началом списка аргументов шаблона ([temp.names]) или оператором «меньше». Идентификатор сначала ищется в классе выражения объекта. Если идентификатор не найден, он затем ищется в контексте всего postfix-expressionи должен дать имя шаблону класса.

Если id-expressionin a class member access - это unqualified-id, а тип выражения объекта относится к типу класса C, unqualified-idищется в области действия класса C. Для pseudo-destructor call, то unqualified-idищется в контексте полной postfix-expression.

Если unqualified-idесть , то ищется в контексте всего . Если тип объектного выражения относится к типу класса , он также ищется в области действия класса . По крайней мере, один из поисков должен найти имя, которое относится к . [ ~type-nametype-namepostfix-expression T Ctype-name C cv T Example:

struct A { };

struct B {
  struct A { };
  void f(::A* a);
};

void B::f(::A* a) {
  a->~A();                      // OK: lookup in *a finds the injected-class-name
}

 — end example ]

Если id-expressionдоступ для члена класса имеет qualified-idформу

class-name-or-namespace-name::...

class-name-or-namespace-name следуя . или -> оператор сначала ищется в классе выражения объекта и имя, если он найден, используется. В противном случае он ищется в контексте всего postfix-expression. [  Note: См. [basic.lookup.qual], Где описан поиск имени ранее ​::​, при котором будет найден только тип или имя пространства имен. ]  — end note 

Если qualified-idимеет вид

::class-name-or-namespace-name::...

class-name-or-namespace-name ищется в глобальном масштабе в виде class-nameили namespace-name.

Если nested-name-specifierсодержит a simple-template-id, имена в нем template-arguments ищутся в контексте, в котором postfix-expressionвстречается все.

Если id-expressionэто a conversion-function-id, его conversion-type-id сначала ищут в классе выражения объекта, и имя, если оно найдено, используется. В противном случае он ищется в контексте всего postfix-expression. В каждом из этих поисков учитываются только имена, обозначающие типы или шаблоны, специализацией которых являются типы. [ Example:

struct A { };
namespace N {
  struct A {
    void g() { }
    template <class T> operator T();
  };
}

int main() {
  N::A a;
  a.operator A();               // calls N​::​A​::​operator N​::​A
}

 — end example ]

В using-directiveor namespace-alias-definition, во время поиска namespace-nameили для имени в nested-name-specifier пространстве имен учитываются только имена.

Программа должна содержать глобальную функцию с именем main. Выполнение программы запускает основной поток выполнения ([intro.multithread], [thread.threads]), в котором main вызывается функция и в котором переменные статической продолжительности хранения могут быть инициализированы ([basic.start.static]) и уничтожены ([basic.start.term]). Это определяется реализацией, требуется ли программа в автономной среде для определения main функции. [  Note: В автономной среде запуск и завершение определяются реализацией; start-up содержит выполнение конструкторов для объектов области пространства имен со статической продолжительностью хранения; завершение содержит выполнение деструкторов для объектов со статической продолжительностью хранения. ]  — end note 

Реализация не должна предопределять main функцию. Эта функция не должна быть перегружена. Его тип должен иметь связь с языком C ++, и он должен иметь объявленный тип возвращаемого значения int, но в остальном его тип определяется реализацией. Реализация должна позволять как

• (2.1)

  функция () возврата int и

• (2.2)

  функция (int, указатель на указатель на char) возврат int

как тип main ([dcl.fct]). В последней форме, с целью демонстрации, вызывается первый параметр функции и вызывается второй параметр функции , где должно быть количество аргументов, переданных программе из среды, в которой программа выполняется. Если не равно нулю эти аргументы должны быть поставлены в счете в качестве указателей на начальные символы с завершающим нулевыми мультибайтными строками ( ntmbs с) ( ) и должны быть указателем на начальный характер ntmbs , который представляет собой имя , используемое для запуска программы или . Значение должно быть неотрицательным. Значение должно быть 0. [ Рекомендуется добавлять любые дополнительные (необязательные) параметры после . ] argc argv argc argc argv[0] argv[argc-1] [multibyte.strings] argv[0] "" argc argv[argc]  Note: argv  — end note 

Функцию main нельзя использовать в программе. Из вне реализации. Программа , которая определяет , как удаленные или что декларирует быть , или плохо сформированным. Функция не должна быть объявлена с . Программа, которая объявляет переменную в глобальной области видимости или объявляет имя с привязкой к языку C (в любом пространстве имен), имеет неправильный формат. Имя не зарезервировано. [ Функции-члены, классы и перечисления могут быть вызваны , как и сущности в других пространствах имен. ] linkage main main main inline static constexpr main linkage-specification main main main  Example: main  — end example 

Завершение программы без выхода из текущего блока (например, путем вызова функции std​::​exit(int)) не уничтожает никаких объектов с автоматической продолжительностью хранения ([class.dtor]). Если std​::​exit вызывается для завершения программы во время уничтожения объекта со статической продолжительностью хранения или продолжительностью хранения потока, программа имеет неопределенное поведение.

Оператор return in main имеет эффект выхода из основной функции (уничтожение любых объектов с автоматической продолжительностью хранения) и вызова std​::​exit с возвращаемым значением в качестве аргумента. Если управление потоками от конца compound-statementиз main, эффект эквивалентен return с операндом 0 (также см [except.handle]).

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

A constant initializer для переменной или временного объекта o - это инициализатор, полное выражение которого является константным выражением, за исключением того, что если o это объект, такой инициализатор может также вызывать конструкторы constexpr для o и его подобъектов, даже если эти объекты относятся к нелитеральным типам классов. [  Note: Такой класс может иметь нетривиальный деструктор. ] выполняется, если переменный или временный объект со статической продолжительностью хранения или хранением потока инициализируется константным инициализатором для сущности. Если постоянная инициализация не выполняется, переменная с или есть . Вместе вызываются инициализация нулем и инициализация константой ; все остальные инициализации есть . Всякая статическая инициализация строго происходит до ( ) любой динамической инициализации. [ Динамическая инициализация нелокальных переменных описана в ; локальные статические переменные описаны в . ]  — end note Constant initialization static storage duration thread storage duration zero-initializedstatic initialization dynamic initialization[intro.races] Note: [basic.start.dynamic] [stmt.dcl]  — end note 

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

• (3.1)

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

• (3.2)

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

[  Note: Как следствие, если инициализация объекта obj1 относится к объекту obj2 области пространства имен, потенциально требующему динамической инициализации и определенному позже в той же единице преобразования, не указано, будет ли значение obj2 used значением полностью инициализированного obj2 (поскольку obj2 было статически инициализирован) или будет obj2 просто нулевым значением. Например,

inline double fd() { return 1.0; }
extern double d1;
double d2 = d1;     // unspecified:
                    // may be statically initialized to 0.0 or
                    // dynamically initialized to 0.0 if d1 is
                    // dynamically initialized, or 1.0 otherwise
double d1 = fd();   // may be initialized statically or dynamically to 1.0

 — end note ]

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

Динамическая инициализация нелокальных переменных V и W со статической продолжительностью хранения упорядочены следующим образом :

• (2.1)

  Если V и W имеют упорядоченную инициализацию и V определены ранее W в одной единице трансляции, инициализация V выполняется в последовательности перед инициализацией W.

• (2.2)

  Если V имеет частично упорядоченную инициализацию, W не имеет неупорядоченной инициализации и V определен ранее W в каждой единице перевода, в которой W определена, то

  • (2.2.1)

    если программа запускает поток ([intro.multithread]), отличный от основного потока ([basic.start.main]), инициализация V строго выполняется до инициализации W;

  • (2.2.2)

    в противном случае инициализация V выполняется до инициализации W.

• (2.3)

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

• (2.4)

  В противном случае инициализации V и W имеют неопределенную последовательность.

[  Note: Это определение позволяет инициализировать последовательность упорядоченных переменных одновременно с другой последовательностью. ] — end note 

A non-initialization odr-use - это odr-use ([basic.def.odr]), не вызванная прямо или косвенно инициализацией нелокальной статической переменной или переменной продолжительности хранения потока.

Это определяется реализацией, будет ли динамическая инициализация нелокальной внелинейной переменной со статической продолжительностью хранения последовательно перед первым оператором main или откладывается. Если это отложено, это обязательно произойдет до любого неинициализационного odr-использования любой не встроенной функции или не встроенной переменной, определенной в той же единице перевода, что и инициализируемая переменная.36 Это определяется реализацией, в каких потоках и в каких точках программы происходит такая отложенная динамическая инициализация. [  Note: Такие точки следует выбирать таким образом, чтобы позволить программисту избежать взаимоблокировок. ] [ — end note  Example:

// - File 1 -
#include "a.h"
#include "b.h"
B b;
A::A(){
  b.Use();
}

// - File 2 -
#include "a.h"
A a;

// - File 3 -
#include "a.h"
#include "b.h"
extern A a;
extern B b;

int main() {
  a.Use();
  b.Use();
}

Это определяется реализацией ли либо a или b инициализируется до main ввода , или задерживаются на инициализацию до тех пор , a пока первый ODR используемый в main. В частности, если a инициализируется до main ввода, не гарантируется, что b будет инициализирован до того, как он будет использован odr при инициализации a, то есть перед вызовом A​::​A . Если, однако, a инициализируется в какой-то момент после первого оператора main, b будет инициализирован до его использования в A​::​A. ]  — end example 

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

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

Если инициализация нелокальной переменной со статической продолжительностью хранения или продолжительностью хранения потока завершается через исключение, std​::​terminate вызывается.

Destructors для инициализированных объектов (то есть объектов, которые lifetime были начаты) со статической продолжительностью хранения, и функции, зарегистрированные с помощью std​::​atexit, вызываются как часть вызова . Вызов выполняется до вызова деструкторов и зарегистрированных функций. [ Возврат из invokes ( ). ]std​::​exit std​::​exit  Note: main std​::​exit [basic.start.main] — end note 

Деструкторы для инициализированных объектов с продолжительностью хранения потока в данном потоке вызываются в результате возврата из начальной функции этого потока и в результате вызова этого потока std​::​exit. Завершение деструкторов для всех инициализированных объектов с длительностью хранения потока в этом потоке строго происходит до инициирования деструкторов любого объекта со статической продолжительностью хранения.

Если завершение конструктора или динамическая инициализация объекта со статической продолжительностью хранения сильно происходит раньше, чем у другого, завершение деструктора второго упорядочивается до инициирования деструктора первого. Если завершение конструктора или динамическая инициализация объекта с продолжительностью хранения потока происходит раньше, чем у другого, завершение деструктора второго выполняется до запуска деструктора первого. Если объект инициализируется статически, он уничтожается в том же порядке, как если бы объект был инициализирован динамически. Для объекта типа массива или класса все подобъекты этого объекта уничтожаются до того, как будет уничтожен любой объект блочной области со статической продолжительностью хранения, инициализированный во время построения подобъектов. Если уничтожение объекта со статической продолжительностью хранения или продолжительностью хранения потока завершается через исключение, std​::​terminate вызывается.

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

Если завершение инициализации объекта со статической продолжительностью хранения происходит строго перед вызовом std​::​atexit (см. <cstdlib>, [support.start.term]), Вызов переданной функции std​::​atexit упорядочивается до вызова деструктора для объекта. Если вызов std​::​atexit строго происходит до завершения инициализации объекта со статической продолжительностью хранения, вызов деструктора для объекта упорядочивается до вызова переданной функции std​::​atexit. Если вызов std​::​atexit строго происходит перед другим вызовом std​::​atexit, вызов функции, переданной второму std​::​atexit вызову, упорядочивается до вызова функции, переданной первому std​::​atexit вызову.

Если в обработчиках сигналов ([support.runtime]) не разрешено использование объекта стандартной библиотеки или функции , которая не happen before завершает уничтожение объектов со статической продолжительностью хранения и выполнение std​::​atexit зарегистрированных функций ([support.start.term]), программа имеет неопределенное поведение. [  Note: Если есть использование объекта со статической продолжительностью хранения, которое не происходит до разрушения объекта, программа имеет неопределенное поведение. Завершение каждого потока перед вызовом std​::​exit или выходом из main него достаточно, но не обязательно, чтобы удовлетворить этим требованиям. Эти требования разрешают диспетчеры потоков как объекты статической продолжительности хранения. ]  — end note 

Вызов функции, std​::​abort() объявленной в, <cstdlib> завершает программу без выполнения каких-либо деструкторов и без вызова функций, переданных в std​::​atexit() или std​::​at_­quick_­exit().

Все переменные, которые не имеют динамической продолжительности хранения, не имеют продолжительности хранения потоков и не являются локальными, имеют static storage duration. Хранение этих объектов должно длиться на время программы ([basic.start.static], [basic.start.term]).

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

Ключевое слово static можно использовать для объявления локальной переменной со статической продолжительностью хранения. [  Note: [stmt.dcl] описывает инициализацию локальных static переменных; [basic.start.term] описывает уничтожение локальных static переменных. ]  — end note 

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

Все переменные, объявленные с thread_­local ключевым словом, имеют thread storage duration. Хранение этих объектов должно длиться в течение всего потока, в котором они созданы. Для каждого потока существует отдельный объект или ссылка, и использование объявленного имени относится к сущности, связанной с текущим потоком.

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

Блок-область видимости переменных явно не объявлены static, thread_­localили extern есть automatic storage duration. Хранилище для этих сущностей длится до тех пор, пока блок, в котором они созданы, не завершится.

[  Note: Эти переменные инициализируются и уничтожаются, как описано в [stmt.dcl]. ] — end note 

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

Объекты можно создавать динамически во время program executionиспользования и уничтожать с помощью . Реализация C ++ обеспечивает доступ и управление динамической памятью через глобальное и глобальное и . [ Формы без выделения памяти, описанные в , не выполняют выделение или освобождение. ]new-expressionsdelete-expressionsallocation functions operator new operator new[] deallocation functions operator delete operator delete[] Note: [new.delete.placement] — end note 

Библиотека предоставляет определения по умолчанию для функций глобального распределения и освобождения. Некоторые функции глобального распределения и освобождения можно заменить ([new.delete]). Программа на C ++ должна предоставлять не более одного определения заменяемой функции выделения или освобождения. Любое такое определение функции заменяет версию по умолчанию, предоставленную в library ([replacement.functions]). Следующие функции выделения и освобождения ([support.dynamic]) неявно объявляются в глобальной области видимости в каждой единице трансляции программы.

void* operator new(std::size_t);
void* operator new(std::size_t, std::align_val_t);

void operator delete(void*) noexcept;
void operator delete(void*, std::size_t) noexcept;
void operator delete(void*, std::align_val_t) noexcept;
void operator delete(void*, std::size_t, std::align_val_t) noexcept;

void* operator new[](std::size_t);
void* operator new[](std::size_t, std::align_val_t);

void operator delete[](void*) noexcept;
void operator delete[](void*, std::size_t) noexcept;
void operator delete[](void*, std::align_val_t) noexcept;
void operator delete[](void*, std::size_t, std::align_val_t) noexcept;

Эти неявные декларации ввести только имена функций operator new, operator new[], operator deleteи operator delete[]. [  Note: Неявные декларации не вводить имена std, std​::​size_­t, std​::​align_­val_­tили любые другие имена , которые библиотека использует , чтобы объявить эти имена. Таким образом, new-expression, delete-expressionили вызов функции , которая относится к одной из этих функций , не включая заголовок <new> правильно сформирован. Однако ссылка на std or std​::​size_­t или std​::​align_­val_­t неправильно сформирована, если имя не было объявлено путем включения соответствующего заголовка. ] Функции распределения и / или освобождения также могут быть объявлены и определены для любого класса ( ).  — end note [class.free]

Любые функции распределения и / или освобождения, определенные в программе C ++, включая версии по умолчанию в библиотеке, должны соответствовать семантике, указанной в [basic.stc.dynamic.allocation] и [basic.stc.dynamic.deallocation].

Продолжительность хранения подобъектов и ссылочных элементов - это время хранения их полного объекта ([intro.object]).

Объекты, объявленные как символы (char), должны быть достаточно большими, чтобы хранить любой член базового набора символов реализации. Если символ из этого набора хранится в символьном объекте, интегральное значение этого символьного объекта равно значению односимвольной буквальной формы этого символа. Это определяется реализацией, char может ли объект содержать отрицательные значения. Персонажи могут быть объявлены явно или . Обычный , и - это три разных типа, которые вместе называются . A , a и an занимают одинаковый объем памяти и имеют одинаковые значения ; то есть они имеют одно и то же объектное представление. Для узких символьных типов все биты представления объекта участвуют в представлении значения. [ Битовое поле узкого символьного типа, длина которого больше, чем количество бит в представлении объекта этого типа, имеет биты заполнения; см . ] Для беззнаковых узких символьных типов каждый возможный битовый шаблон представления значения представляет отдельное число. Эти требования не действуют для других типов. В любой конкретной реализации простой объект может принимать те же значения, что и a, или a ; какой из них определяется реализацией. Для каждого значения типа в диапазоне от 0 до 255 включительно существует такое значение типа , что результат от до равен , а результат интегрального преобразования от до равен . unsigned signed char signed char unsigned char narrow character types char signed charunsigned char alignment requirements Note: [class.bit] — end note  char signed char unsigned char i unsigned char j char integral conversion i char jj unsigned char i

Всего их пять standard signed integer types : « », « », « », « » и « ». В этом списке каждый тип обеспечивает по крайней мере такой же объем памяти, как и предыдущие в списке. Также может быть определено реализацией . Стандартные и расширенные целочисленные типы со знаком называются вместе . Обычные имеют естественный размер, предполагаемый архитектурой среды исполнения ; другие целочисленные типы со знаком предоставляются для особых нужд.signed charshort intintlong intlong long intextended signed integer typessigned integer typesint47

Для каждого из стандартных целочисленных типов со знаком существуют соответствующие (но разные) standard unsigned integer type: « », « », « », « » и « », каждый из которых занимает такой же объем памяти и имеет то же самое, что и соответствующий знаковый целочисленный тип ; то есть каждый знаковый целочисленный тип имеет то же представление объекта, что и соответствующий ему беззнаковый целочисленный тип. Аналогично, для каждого из расширенных целочисленных типов со знаком существует соответствующий с одинаковым объемом памяти и требованиями к выравниванию. Стандартные и расширенные целочисленные типы без знака называются вместе . Диапазон неотрицательных значений целочисленного типа со знаком является поддиапазоном соответствующего целочисленного типа без знака, представление одного и того же значения в каждом из двух типов является одинаковым, и представление значения каждого соответствующего типа со знаком / без знака должно быть таким же. Стандартные целочисленные типы со знаком и стандартные целочисленные типы без знака вместе называются , а расширенные целочисленные типы со знаком и расширенные целочисленные типы без знака вместе называются . Целочисленные типы со знаком и без знака должны удовлетворять ограничениям, приведенным в стандарте C, раздел 5.2.4.2.1.unsigned charunsigned short intunsigned intunsigned long intunsigned long long int alignment requirements 48extended unsigned integer type unsigned integer types standard integer typesextended integer types

Целые числа без знака должны подчиняться законам арифметики по модулю, $2^n$ где n - количество бит в представлении значения этого конкретного размера целого числа.49

Тип wchar_­t - это отдельный тип, значения которого могут представлять различные коды для всех членов самого большого расширенного набора символов, указанного среди поддерживаемых locales. Тип wchar_­t должен иметь такой же размер, подписи и, alignment requirements как и один из других интегральных типов, называться своим underlying type. Типы char16_­t и char32_­t обозначают отдельные типы с тем же размером, подписью и выравниванием, что uint_­least16_­t и и uint_­least32_­t, соответственно, в <cstdint>, называемые базовыми типами.

Значения типа bool : либо, true либо false.50 [  Note: Там нет signed, unsigned, shortили long bool типов или значения. ] Значения типа участвуют в .  — end note bool integral promotions

Типы bool, char, char16_­t, char32_­t, wchar_­t, и подписанные и неподписанные целые типы собирательно называются integral типами.51 Синонимом интегрального типа является . Представления целочисленных типов должны определять значения с использованием чистой двоичной системы счисления. [ Этот международный стандарт допускает представление двух дополнений, единиц дополнения и знаковых величин для целочисленных типов. ]integer type52 Example:  — end example 

Есть три floating-point типа: float, double, и long double. Тип double обеспечивает по крайней мере такую ​​же точность float, а тип long double обеспечивает по крайней мере такую ​​же точность, как double. Набор значений типа float - это подмножество набора значений типа double; набор значений типа double - это подмножество набора значений типа long double. Представление значений типов с плавающей запятой определяется реализацией. [  Note: Настоящий международный стандарт не предъявляет требований к точности операций с плавающей запятой; см. также [support.limits]. ] Целые и плавающие типы вместе называются типами. Специализации шаблона стандартной библиотеки должны определять максимальные и минимальные значения каждого арифметического типа для реализации. — end note  arithmetic std​::​numeric_­limits

Тип cv void - это неполный тип, который не может быть завершен; такой тип имеет пустой набор значений. Он используется в качестве возвращаемого типа для функций, не возвращающих значение. Любое выражение можно explicitly converted набрать cv void. Выражение типа cv void должно быть использовано только в качестве expression statement, в качестве операнда comma expression, в качестве второго или третьего операнда ?: ([expr.cond]), как операнд typeid, noexceptили decltype, как выражение в return statement для функции с типом возвращаемого cv void, или как операнд явного преобразования в тип cv void.

Значение типа std​::​nullptr_­t - это null pointer constant. Такие значения участвуют в преобразовании указателя и указателя на член ([conv.ptr], [conv.mem]). sizeof(std​::​nullptr_­t) будет равно sizeof(void*).

[  Note: Даже если реализация определяет два или более базовых типа, которые имеют одинаковое представление значения, они, тем не менее, являются разными типами. ] — end note 

Составные типы могут быть созданы следующими способами:

• (1.1)

  arrays объектов данного типа [dcl.array],;

• (1.2)

  functions, которые имеют параметры заданных типов и возвращают, void или ссылки, или объекты заданного типа [dcl.fct],;

• (1.3)

  pointers в cv void или объекты или функции (включая статические члены классов) данного типа [dcl.ptr];

• (1.4)

  references к объектам или функциям данного типа [dcl.ref]. Есть два типа ссылок:

  • (1.4.1)

    lvalue reference

  • (1.4.2)

    rvalue reference

• (1.5)

  classes содержащий последовательность объектов различных типов (Clause [class]), набор типов, перечислений и функций для управления этими объектами ([class.mfct]) и набор ограничений на доступ к этим объектам (Clause [class.access]);

• (1.6)

  unions, Которые являются классы , способные содержать объекты разных типов в разные моменты времени, [class.union];

• (1.7)

  enumerations, которые содержат набор именованных постоянных значений. Каждое отдельное перечисление представляет собой различное enumerated type, [dcl.enum];

• (1.8)

  pointers to non-static class members,53 Которые идентифицируют пользователей данного типа в пределах объектов данного класса, [dcl.mptr].

Эти методы построения типов можно применять рекурсивно; ограничения указаны в [dcl.ptr], [dcl.array], [dcl.fct], и [dcl.ref]. Создание типа, в котором количество байтов в его объектном представлении превышает максимальное значение, представленное в type std​::​size_­t ([support.types]), является плохо сформированным.

Тип указателя cv void или указателя на тип объекта называется object pointer type. [  Note: Указатель на void не имеет типа указатель на объект, потому что void не является типом объекта. ] Тип указателя, который может обозначать функцию, называется a . Указатель на объекты типа называется «указателем на ». [ Указатель на объект типа называется «указателем на », а указатель на объект класса называется «указателем на ». ] За исключением указателей на статические члены, текст, относящийся к «указателям», не применяется к указателям на члены. Указатели на неполные типы разрешены, хотя есть ограничения на то, что с ними можно делать ( ). Каждое значение типа указателя является одним из следующих:  — end note  function pointer type T T Example: int int X X  — end example [basic.align]

• (3.1)

  a pointer to объект или функция (говорят, что указатель point на объект или функцию), или

• (3.2)

  pointer past the end of объект ([expr.add]), или

• (3.3)

  null pointer value ([conv.ptr]) для этого типа, или

• (3.4)

  ан invalid pointer value.

Значение типа указателя, которое является указателем на конец или после конца объекта represents the address первого байта в памяти ([intro.memory]), занятого объектом,54 или первого байта в памяти после конца памяти, занятой объектом, соответственно. [  Note: Указатель за концом объекта ([expr.add]) не считается указывающим на несвязанный объект типа объекта, который может быть расположен по этому адресу. Значение указателя становится недействительным, когда память, которую он обозначает, достигает конца срока хранения; см [basic.stc]. ] Для целей и сравнения ( , ), указатель за конец последнего элемента массива из элементов считаются эквивалентным указателем на гипотетический элемент . Представление значений типов указателей определяется реализацией. Указатели на типы, совместимые с макетом, должны иметь одинаковое представление значения и . [ Указатели не должны иметь специального представления, но их диапазон допустимых значений ограничен расширенным требованием выравнивания. ] — end note  pointer arithmetic[expr.rel] [expr.eq] x n x[n] alignment requirements Note: over-aligned types  — end note 

Два объекта a и b являются, pointer-interconvertible если:

• (4.1)

  это один и тот же объект, или

• (4.2)

  один - объект объединения стандартного макета, а другой - нестатический член данных этого объекта ([class.union]), или

• (4.3)

  один является объектом класса стандартного макета, а другой - первым нестатическим членом данных этого объекта, или, если объект не имеет нестатических членов данных, первым подобъектом базового класса этого объекта ([class.mem]) или

• (4.4)

  существует такой объект c , что a и c являются взаимопреобразуемыми по указателям, и c и b являются взаимопреобразуемыми по указателям.

Если два объекта взаимопреобразуемы по указателю, то они имеют одинаковый адрес, и можно получить указатель на один из указателя на другой через a reinterpret_­cast. [  Note: Объект массива и его первый элемент не являются взаимопреобразуемыми по указателям, даже если они имеют одинаковый адрес. ] — end note 

Указатель на cv-qualified или cv-unqualified void может использоваться для указания на объекты неизвестного типа. Такой указатель должен содержать любой указатель на объект. Объект типа cv void* должен иметь те же требования к представлению и выравниванию, что и cv char*.

Тип, упомянутый в [basic.fundamental] и [basic.compound] - это cv-unqualified type. Каждый тип, который является cv-неквалифицированным полным или неполным типом объекта или is void ([basic.types]), имеет три соответствующих cv-квалифицированных версии своего типа: const-qualified версия, volatile-qualified версия и const-volatile-qualified версия. Тип объекта ([intro.object]) включает в себя cv-qualifiers указано в decl-specifier-seq, declarator, type-id, или new-type-idпри создании объекта.

• (1.1)

  A const object - объект типа const T или неизменяемый подобъект такого объекта.

• (1.2)

  A volatile object - это объект типа volatile T, подобъект такого объекта или изменяемый подобъект константного изменчивого объекта.

• (1.3)

  A const volatile object - это объект типа const volatile T, неизменяемый подобъект такого объекта, константный подобъект изменчивого объекта или неизменяемый изменчивый подобъект константного объекта.

Варианты типа cv-qualified или cv-unqualified являются отдельными типами; однако они должны иметь одинаковое представление и alignment requirements.55

A compound type не квалифицируется cv-квалификаторами (если есть) типов, из которых он составлен. Любые cv-квалификаторы, применяемые к типу массива, влияют на тип элемента массива ([dcl.array]).

См [dcl.fct] и [class.this] относительно типов функций , которые имеют cv-qualifiers.

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

В этом международном стандарте нотация cv (или cv1, cv2и т. Д.), Используемая в описании типов, представляет произвольный набор cv-квалификаторов, т. Е. Один из {const}, {volatile}, {const, volatile} или пустой набор. Для типа cv T, то top-level cv-qualifiers из этого типа являются те , которые обозначены cv. [  Example: Тип, соответствующий типу type-id const int& , не имеет квалификаторов CV верхнего уровня. Тип, соответствующий type-id volatile int * const тегу, имеет квалификатор cv верхнего уровня const. Для типа класса тип C, соответствующий классу , type-id void (C​::​* volatile)(int) const имеет квалификатор cv верхнего уровня volatile. ] — end example 

Cv-квалификаторы, применяемые к типу массива, присоединяются к базовому типу элемента, поэтому обозначение «cv T», где T является типом массива, относится к массиву, элементы которого квалифицируются таким образом. Тип массива, элементы которого имеют cv-квалификацию, также считается имеющим такую ​​же cv-квалификацию, что и его элементы. [ Example:

typedef char CA[5];
typedef const char CC;
CC arr1[5] = { 0 };
const CA arr2 = { 0 };

Типом обоих arr1 и arr2 является «массив из 5 const char», а тип массива считается квалифицированным константой. ] — end example