Difference between revisions of "cpp/language/type"

Revision as of 00:42, 28 June 2021

Objects, references, functions including function template specializations, and expressions have a property called type, which both restricts the operations that are permitted for those entities and provides semantic meaning to the otherwise generic sequences of bits.

Type classification

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

• fundamental types (see also std::is_fundamental):

• the type void (see also std::is_void);
• the type std::nullptr_t (since C++11) (see also std::is_null_pointer);
• arithmetic types (see also std::is_arithmetic):

• floating-point types (float, double, long double and their cv-qualified versions) (see also std::is_floating_point);
• integral types (including cv-qualified versions, see also std::is_integral):

• the type bool;
• character types:

• narrow character types:

• ordinary character types (char, signed char, unsigned char)
• the type char8_t (since C++20)

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

• signed integer types (short int, int, long int, long long int);
• unsigned integer types (unsigned short int, unsigned int, unsigned long int, unsigned long long int);

• compound types (see also std::is_compound):

• reference types (see also std::is_reference):

• lvalue reference types (see also std::is_lvalue_reference):

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

• rvalue reference types (see also std::is_rvalue_reference):

• rvalue reference to object types;
• rvalue reference to function types;

• pointer types (see also std::is_pointer):

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

• pointer-to-member types (see also std::is_member_pointer):

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

• array types (see also std::is_array);
• function types (see also std::is_function);
• enumeration types (see also std::is_enum);
• class types:

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

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

Types are grouped in various categories based on their properties:

• object types are (possibly cv-qualified) types that are not function types, reference types, or the type void (see also std::is_object);
• scalar types are (possibly cv-qualified) object types that are not array types or class types (see also std::is_scalar);
• trivial types (see also std::is_trivial), POD types (see also std::is_pod), literal types (see also std::is_literal_type), and other categories listed in the the type traits library or as named type requirements.

Type naming

A name 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 as type-id. The syntax of the type-id that names type T is exactly the syntax of a declaration of a variable or function of type T, with the identifier omitted, except that decl-specifier-seq of the declaration grammar is constrained to type-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 int
static_cast<int*>(p); // type-id is "int*"
 
int a[3];   // declaration of an array of 3 int
new int[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 int
new (int (*(*[2])())[3]); // type-id is "int (*(*[2])())[3]"
 
void f(int);                    // declaration of a function taking int and returning void
std::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 int
sizeof(std::vector<int>); // type-id is "std::vector<int>"
 
struct { int x; } b;         // creates a new type and declares an object b of that type
sizeof(struct{ int x; });    // error: cannot define new types in a sizeof expression
using t = struct { int x; }; // creates a new type and declares t as an alias of that type
 
sizeof(static int); // error: storage class specifiers not part of type-specifier-seq
std::function<inline void(int)> f; // error: neither are function specifiers

The declarator part of the declaration grammar with the name removed is referred to as abstract-declarator.

Type-id may be used in the following situations:

• to specify the target type in cast expressions;
• as arguments to sizeof, alignof, alignas, new, and typeid;
• on the right-hand side of a type alias declaration;
• as the trailing return type of a function declaration;
• as the default argument of a template type parameter;
• as the template argument for a template type parameter;
• in dynamic exception specification.

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

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

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

See elaborated type specifier for details.

Static type

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

Dynamic type

If some glvalue expression refers to a polymorphic object, the type of its most derived object is known as the dynamic type.

// given
struct B { virtual ~B() {} }; // polymorphic type
struct D: B {}; // polymorphic type
D d; // most-derived object
B* 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.

Incomplete type

The following types are incomplete types:

• the type void (possibly cv-qualified);
• incompletely-defined object types:
  • class type that has been declared (e.g. by forward 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 type T to be complete:

• definition or function call to a function with return type T or argument type T;
• definition of an object of type T;
• declaration of a non-static class data member of type T;
• new-expression for an object of type T or an array whose element type is T;
• lvalue-to-rvalue conversion applied to a glvalue of type T;
• an implicit or explicit conversion to type T;
• a standard conversion, dynamic_cast, or static_cast to type T* or T&, except when converting from the null pointer constant or from a pointer to void;
• class member access operator applied to an expression of type T;
• typeid, sizeof, or alignof operator applied to type T;
• arithmetic operator applied to a pointer to T;
• definition of a class with base class T;
• assignment to an lvalue of type T;
• a catch-clause for an exception of type T, T&, or T*.

(In general, when the size and layout of T 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 as class X) might be incomplete at one point in a translation unit and complete later on; the type class X is the same type at both points:

struct X;             // X is an incomplete type
extern X* xp;         // xp is a pointer to an incomplete type
 
void foo() {
  xp++;               // ill-formed: X is incomplete
}
 
struct X { int i; };  // now X is a complete type
 
X x;
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 of T" and "array of N T") are different types.

The type of a pointer to array of unknown bound, or to a type defined by a typedef declaration to be an array of unknown bound, cannot be completed.

extern int arr[];   // the type of arr is incomplete
typedef int UNKA[]; // UNKA is an incomplete type
UNKA* arrp;         // arrp is a pointer to an incomplete type
UNKA** arrpp;
 
void foo() {
  arrp++;           // error: incomplete type
  arrpp++;          // OK: sizeof UNKA* is known
}
 
int arr[10];        // now the type of arr is complete
 
void bar() {
  arrp = &arr;      // error: different types
  arrp++;           // error: UNKA can’t be completed
}

See also