Elaborated type specifier

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

C++ language

General topics
Preprocessor Comments	Keywords Escape sequences
Flow control
Conditional execution statements
if	switch
Iteration statements (loops)
for range-for (C++11)	while do-while
Jump statements
continue - break	goto - return
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications (until C++20)
noexcept specifier (C++11)
Exceptions
throw-expression	try-catch block
Namespaces
Namespace declaration	Namespace aliases
Types
Fundamental types Enumeration types Function types	Class/struct types Union types
Specifiers
decltype (C++11) auto (C++11) alignas (C++11)	const/volatile constexpr (C++11)
Storage duration specifiers
Initialization
Default initialization Value initialization Zero initialization Copy initialization Direct initialization	Aggregate initialization List initialization (C++11) Constant initialization Reference initialization

Expressions
Value categories Order of evaluation	Operators Operator precedence
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions - Explicit conversions
static_cast - dynamic_cast
const_cast - reinterpret_cast
Memory allocation
new expression	delete expression
Classes
Class declaration Constructors this pointer	Access specifiers friend specifier
Class-specific function properties
Virtual function override specifier (C++11) final specifier (C++11)	explicit (C++11) static
Special member functions
Default constructor Copy constructor Move constructor (C++11)	Copy assignment Move assignment (C++11) Destructor
Templates
Class template Function template	Template specialization Parameter packs (C++11)
Miscellaneous
Inline assembly	History of C++

 

Declarations

Overview declaration syntax decl-specifier-seq declarator Specifiers typedef inline virtual function specifier explicit function specifier    friend constexpr (C++11) consteval (C++20) constinit (C++20) storage class specifiers translation-unit-local (C++20) class/struct union enum decltype (C++11) auto (C++11) alignas (C++11) constvolatile elaborated type specifier attributes (C++11)

Declarators reference pointer array Block declarations simple-declaration → structured binding declaration (C++17) alias declaration(C++11) namespace alias definition using-declaration using-directive static_assert declaration (C++11) asm-declaration opaque enum declaration(C++11) Other declarations namespace definition function declaration class template declaration function template declaration explicit template instantiation(C++11) explicit template specialization linkage specification attribute declaration (C++11) empty declaration

 

Elaborated type specifiers may be used to refer to a previously-declared class name (class, struct, or union) or to a previously-declared enum name even if the name was hidden by a non-type declaration. They may also be used to declare new class names.

Syntax

class-key class-name	(1)
enum enum-name	(2)
class-key attr(optional) identifier ;	(3)

class-key	-	one of class, struct, union
class-name	-	the name of a previously-declared class type, optionally qualified, or an identifier not previously declared as a type name
enum-name	-	the name of a previously-declared enumeration type, optionally qualified

1) elaborated type specifier for a class type

2) elaborated type specifier for a enumeration type

3) A declaration that consists solely of an elaborated type specifier always declares a class type named by identifier in the scope that contains the declaration.

Opaque enum declaration resembles form (3), but the enum type is a complete type after an opaque enum declaration.

Explanation

Form (3) is a special case of elaborated type specifier, usually referred to as forward declaration of classes, for the description of form (3), see Forward declaration. The following only apply to form (1) and (2).

The class-name or enum-name in the elaborated type specifier may either be a simple identifier or be a qualified-id. The name is looked up using unqualified name lookup or qualified name lookup, depending on their appearance. But in either case, non-type names are not considered.

class T {
public:
    class U;
private:
    int U;
};
 
int main()
{
    int T;
    T t; // error: the local variable T is found
    class T t; // OK: finds ::T, the local variable T is ignored
    T::U* u; // error: lookup of T::U finds the private data member
    class T::U* u; // OK: the data member is ignored
}

If the name lookup does not find a previously declared type name, the elaborated-type-specifier is introduced by class, struct, or union (i.e. not by enum), and class-name is an unqualified identifier, then the elaborated-type-specifier is a class declaration of the class-name.

template <typename T>
struct Node {
    struct Node* Next; // OK: lookup of Node finds the injected-class-name
    struct Data* Data; // OK: declares type Data at global scope
                       // and also declares the data member Data
    friend class ::List; // error: cannot introduce a qualified name
    enum Kind* kind; // error: cannot introduce an enum
};
 
Data* p; // OK: struct Data has been declared

If the name refers to a typedef name, a type alias, a template type parameter, or an alias template specialization, the program is ill-formed, otherwise the elaborated type specifier introduces the name into the declaration the same way a simple type specifier introduces its type-name.

template <typename T>
class Node {
    friend class T; // error: type parameter cannot appear in an elaborated type specifier
};
 
class A {};
enum b { f, t };
 
int main()
{
    class A a; // OK: equivalent to 'A a;'
    enum b flag; // OK: equivalent to 'b flag;'
}

The class-key or enum keyword present in the elaborated-type-specifier must agree in kind with the declaration to which the name in the elaborated-type-specifier refers.

• the enum keyword must be used to refer to an enumeration type (whether scoped or unscoped)
• the union class-key must be used to refer to a union
• either the class or struct class-key must be used to refer to a non-union class type (the keywords class and struct are interchangeable here).

enum class E { a, b };
enum E x = E::a; // OK
enum class E y = E::b; // error: 'enum class' cannot introduce a elaborated type specifier
 
struct A {};
class A a; // OK

When used as a template argument, class T is a type template parameter named T, not an unnamed non-type parameter whose type T is introduced by elaborated type specifier.

References

• C++20 standard (ISO/IEC 14882:2020):

• 6.5.4 Elaborated type specifiers [basic.lookup.elab]

• 9.2.8.3 Elaborated type specifiers [dcl.type.elab]

• C++17 standard (ISO/IEC 14882:2017):

• 6.4.4 Elaborated type specifiers [basic.lookup.elab]

• 10.1.7.3 Elaborated type specifiers [dcl.type.elab]

• C++14 standard (ISO/IEC 14882:2014):

• 3.4.4 Elaborated type specifiers [basic.lookup.elab]

• 7.1.6.3 Elaborated type specifiers [dcl.type.elab]

• C++11 standard (ISO/IEC 14882:2011):

• 3.4.4 Elaborated type specifiers [basic.lookup.elab]

• 7.1.6.3 Elaborated type specifiers [dcl.type.elab]

• C++98 standard (ISO/IEC 14882:1998):

• 3.4.4 Elaborated type specifiers [basic.lookup.elab]

• 7.1.5.3 Elaborated type specifiers [dcl.type.elab]