Objects,references,functions includingfunction template specializations, andexpressions have a property calledtype, which both restricts the operations that are permitted for those entities and provides semantic meaning to the otherwise generic sequences of bits.

[edit]Type classification

The C++ type system consists of the following types:

• fundamental types (see alsostd::is_fundamental):

• the typevoid (see alsostd::is_void);

• arithmetic types (see alsostd::is_arithmetic):

• integral types (includingcv-qualified versions, see alsostd::is_integral, a synonym for integral type is integer type):

• the typebool;
• character types:

• narrow character types:

• ordinary character types:char,signedchar,unsignedchar^[1]

• wide character types:char16_t,char32_t,(since C++11)wchar_t;

• signed integer types:

• standard signed integer types:signedchar,short,int,long,longlong;

• unsigned integer types:

• standard unsigned integer types:unsignedchar,unsignedshort,unsigned,unsignedlong,unsignedlonglong;

• floating-point types (see alsostd::is_floating_point):

• standard floating-point types:float,double,longdouble and theircv-qualified versions;

• compound types (see alsostd::is_compound):

• reference types (see alsostd::is_reference):

• lvalue reference types (see alsostd::is_lvalue_reference):

• lvalue reference to object types;
• lvalue reference to function types;

• pointer types (see alsostd::is_pointer):

• pointer-to-object types;
• pointer-to-function types;

• pointer-to-member types (see alsostd::is_member_pointer):

• pointer-to-data-member types (see alsostd::is_member_object_pointer);
• pointer-to-member-function types (see alsostd::is_member_function_pointer);

• array types (see alsostd::is_array);
• function types (see alsostd::is_function);
• enumeration types (see alsostd::is_enum);

• unscoped enumeration types;

• class types:

• non-union types (see alsostd::is_class);
• union types (see alsostd::is_union).

1. ↑signedchar andunsignedchar are narrow character types, but they are not character types. In other words, the set of narrow character types is not a subset of the set of character types.

For every non-cv-qualified type other than reference and function, the type system supports three additionalcv-qualified versions of that type (const,volatile, andconstvolatile).

[edit]Other categories

Anobject type (see alsostd::is_object) is a (possibly cv-qualified) type that is not a function type, not a reference type, and not (possibly cv-qualified)void.

The following types are collectively calledscalar types (see alsostd::is_scalar):

• arithmetic types
• enumeration types
• pointer types
• pointer-to-member types

• cv-qualified versions of these types

The following types are collectively calledimplicit-lifetime types:

• scalar types
• implicit-lifetime class types
• array types
• cv-qualified versions of these types

[edit]Deprecated categories

[edit]Program-defined type

Aprogram-defined specialization is anexplicit specialization orpartial specialization that is not part of the C++standard library and not defined by the implementation.

Aprogram-defined type is one of the following types:

• A non-closure(since C++11)class type orenumeration type that is not part of the C++ standard library and not defined by the implementation.

• Aninstantiation of a program-defined specialization.

[edit]Type naming

Aname can be declared to refer to a type by means of:

• class declaration;
• union declaration;
• enum declaration;
• typedef declaration;
• type alias declaration.

Types that do not have names often need to be referred to in C++ programs; the syntax for that is known astype-id. The syntax of the type-id that names typeT is exactly the syntax of adeclaration of a variable or function of typeT, with the identifier omitted, except thatdecl-specifier-seq of the declaration grammar is constrained totype-specifier-seq, and that new types may be defined only if the type-id appears on the right-hand side of a non-template type alias declaration.

int* p;// declaration of a pointer to intstatic_cast<int*>(p);// type-id is "int*" int a[3];// declaration of an array of 3 intnewint[3];// type-id is "int[3]" (called new-type-id) int(*(*x[2])())[3];// declaration of an array of 2 pointers to functions// returning pointer to array of 3 intnew(int(*(*[2])())[3]);// type-id is "int (*(*[2])())[3]" void f(int);// declaration of a function taking int and returning voidstd::function<void(int)> x= f;// type template parameter is a type-id "void(int)"std::function<auto(int)->void> y= f;// same std::vector<int> v;// declaration of a vector of intsizeof(std::vector<int>);// type-id is "std::vector<int>" struct{int x;} b;// creates a new type and declares an object b of that typesizeof(struct{int x;});// error: cannot define new types in a sizeof expressionusing t=struct{int x;};// creates a new type and declares t as an alias of that type sizeof(staticint);// error: storage class specifiers not part of type-specifier-seqstd::function<inlinevoid(int)> f;// error: neither are function specifiers

Thedeclarator part of the declaration grammar with the name removed is referred to asabstract-declarator.

Type-id may be used in the following situations:

• to specify the target type incast expressions;
• as arguments tosizeof,alignof,alignas,new, andtypeid;
• on the right-hand side of atype alias declaration;
• as the trailing return type of afunction declaration;
• as the default argument of atemplate type parameter;
• as the template argument for atemplate type parameter;

Type-id can be used with some modifications in the following situations:

• in the parameter list of afunction (when the parameter name is omitted), type-id usesdecl-specifier-seq instead oftype-specifier-seq (in particular, some storage class specifiers are allowed);
• in the name of auser-defined conversion function, the abstract declarator cannot include function or array operators.

[edit]Elaborated type specifier

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 washidden by a non-type declaration. They may also be used to declare new class names.

Seeelaborated type specifier for details.

[edit]Static type

The type of an expression that results from the compile-time analysis of the program is known as thestatic type of the expression. The static type does not change while the program is executing.

[edit]Dynamic type

If someglvalue expression refers to apolymorphic object, the type of its most derived object is known as the dynamic type.

// givenstruct B{virtual ~B(){}};// polymorphic typestruct D: B{};// polymorphic type D d;// most-derived objectB* ptr=&d; // the static type of (*ptr) is B// the dynamic type of (*ptr) is D

For prvalue expressions, the dynamic type is always the same as the static type.

[edit]Incomplete type

The following types areincomplete types:

• the typevoid (possiblycv-qualified);
• incompletely-defined object types:
  • class type that has been declared (e.g. byforward declaration) but not defined;
  • array of unknown bound;
  • array of elements of incomplete type;
  • enumeration type from the point of declaration until its underlying type is determined.

All other types are complete.

Any of the following contexts requires typeT to be complete:

• definition of or call to a function with return typeT or argument typeT;
• definition of an object of typeT;
• declaration of anon-static class data member of typeT;
• new expression for an object of typeT or an array whose element type isT;
• lvalue-to-rvalue conversion applied to a glvalue of typeT;
• animplicit orexplicit conversion to typeT;
• astandard conversion,dynamic_cast, orstatic_cast to typeT* orT&, except when converting from thenull pointer constant or from apointer to possibly cv-qualified void;
• class member access operator applied to an expression of typeT;
• typeid,sizeof, oralignof operator applied to typeT;
• arithmetic operator applied to a pointer toT;
• definition of a class with base classT;
• assignment to an lvalue of typeT;
• ahandler of typeT,T&, orT*.

(In general, when the size and layout ofT must be known.)

If any of these situations occur in a translation unit, the definition of the type must appear in the same translation unit. Otherwise, it is not required.

An incompletely-defined object type can be completed:

• A class type (such asclass X) might be regarded as incomplete at one point in a translation unit and regarded as complete later on; the typeclass X is the same type at both points:

struct X;// declaration of X, no definition provided yetextern X* xp;// xp is a pointer to an incomplete type:// the definition of X is not reachable void foo(){    xp++;// ill-formed: X is incomplete} struct X{int i;};// definition of XX x;// OK: the definition of X is reachable void bar(){    xp=&x;// OK: type is “pointer to X”    xp++;// OK: X is complete}

• The declared type of an array object might be an array of incomplete class type and therefore incomplete; if the class type is completed later on in the translation unit, the array type becomes complete; the array type at those two points is the same type.
• The declared type of an array object might be an array of unknown bound and therefore be incomplete at one point in a translation unit and complete later on; the array types at those two points ("array of unknown bound ofT" and "array ofNT") are different types.

The type of a pointer or reference to array of unknown bound permanently points to or refers to an incomplete type. An array of unknown bound named by atypedef declaration permanently refers to an incomplete type. In either case, the array type cannot be completed:

externint arr[];// the type of arr is incompletetypedefint UNKA[];// UNKA is an incomplete type UNKA* arrp;// arrp is a pointer to an incomplete typeUNKA** arrpp; void foo(){    arrp++;// error: UNKA is an incomplete type    arrpp++;// OK: sizeof UNKA* is known} int arr[10];// now the type of arr is complete void bar(){    arrp=&arr;// OK: qualification conversion (since C++20)    arrp++;// error: UNKA cannot be completed}

[edit]Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit]References

[edit]See also

[edit]External links

• In other languages

• Español
• 日本語
• Русский
• 中文