.CPP File Format – Types

Fundamental types

The types built into the language are listed in [basic.fundamental].

Compound types

Compound types are built from other types [basic.compound].

• An array’s bound is a constant expression and part of its type, so int[3] and int[4] are different types. There are no variable-length arrays in standard C++.
• An array cannot be copied by assignment, and it decays to a pointer to its first element in most expressions. Use std::array where a real value is wanted.
• A type is incomplete if its size is not known, as with void, an array of unknown bound, or a declared but undefined class.
• void* can point to any object type, but cannot be dereferenced.

Enumerations

enum-specifier:
    enum-head { [enumerator-list] }
    enum-head { enumerator-list , }

enum-head:
    enum-key [attribute-specifier-seq] [enum-head-name] [enum-base]

enum-key:   enum | enum class | enum struct
enum-base:  : type-specifier-seq

Writing : type fixes the underlying type. using enum E; (C++20) brings a scoped enumeration’s names into the current scope [enum.udecl].

enum Colour { red, green, blue };          // unscoped, names in enclosing scope
enum class Mode : std::uint8_t { read, write };
enum class Flag;                           // forward declaration, underlying int

int n = red;                               // fine: implicit conversion
int m = static_cast<int>(Mode::read);      // a scoped enum needs a cast

void f(Mode m) {
    switch (m) {
        using enum Mode;                   // C++20
        case read:  break;
        case write: break;
    }
}

const and volatile

A type may be cv-qualified [basic.type.qualifier], [dcl.type.cv]. A non-qualified type and its qualified forms are different types with the same representation.

A qualifier applies to the thing to its left, or, if nothing is on its left, to the thing to its right. Read pointer declarations from right to left.

const int* a;        // pointer to const int: *a cannot be assigned
int const* b;        // the same type as a
int* const c = &x;   // const pointer to int: c itself cannot be reseated
const int* const d = &x;  // const pointer to const int

mutable on a data member allows it to be changed even through a const object, as described on the Classes page. Since C++20 some uses of volatile are deprecated.

References

A reference is an alias for an object or function [dcl.ref]. It has no storage of its own in the language, must be initialised, and cannot be reseated. There are no references to references, no arrays of references and no pointers to references.

std::string make();

const std::string& a = make();     // lifetime extended to the end of a's scope
std::string&& b = make();          // the same, and b is modifiable

const char* c = make().c_str();    // dangling: the temporary dies at the semicolon

Value categories

Every expression has a value category [basic.lval]. The three primary categories are lvalue, xvalue and prvalue. Two more group them: a glvalue is an lvalue or an xvalue, and an rvalue is a prvalue or an xvalue.

A string literal is an lvalue, because it is an array with storage. The name of an rvalue reference variable is an lvalue, because it has a name: std::move or std::forward is what turns it back into an rvalue.

Since C++17 a prvalue is a recipe rather than an object. A prvalue initialises its destination directly, which is what makes copy elision guaranteed. Where a real object is needed, the temporary materialisation conversion [conv.rval] turns a prvalue into an xvalue.

auto and decltype

auto deduces a type from an initialiser [dcl.spec.auto], [dcl.type.auto.deduct]. Deduction works like template argument deduction, so references and top-level const are dropped unless written.

const int& r = n;

auto a = r;            // int: drops const and reference
auto& b = r;           // const int&
const auto c = r;      // const int
auto&& d = n;          // int&: a forwarding reference with an lvalue
auto e = {1, 2, 3};    // std::initializer_list<int>
auto f{1};             // int (since C++17)
auto g = "text";       // const char*

decltype (C++11) gives the type of an entity or expression without evaluating it [dcl.type.decltype].

int x = 0;
decltype(x)   a;       // int
decltype((x)) b = x;   // int&: parentheses make it an lvalue expression

decltype(auto) c = (x);   // int& (C++14): deduces with decltype's rules

auto twice(int v) { return v * 2; }                 // return type deduced (C++14)
auto add(int a, int b) -> int { return a + b; }     // trailing return type (C++11)

auto(x) and auto{x} (C++23) make a prvalue copy of x, decayed as function parameter passing would.

Type properties

Several properties decide what can be done with objects of a type [class.prop], [basic.types.general].

Alignment is the set of address boundaries a type requires [basic.align]. alignof(T) gives it and alignas(n) strengthens it [dcl.align].

Conversions

A standard conversion sequence is at most one conversion from each row group below, in that order [conv]. A conversion may also be user-defined; at most one user-defined conversion is applied implicitly in a chain.

• Converting to an unsigned type is modulo 2^N. Since C++20 converting to a signed type is too; earlier it was implementation-defined.
• Converting a floating-point value to an integer truncates towards zero. The behaviour is undefined if the result does not fit.
• Converting to bool gives false for zero, null pointer and null member pointer, and true otherwise.

int  a = -1;
unsigned b = 1;
bool c = a < b;    // false: a converts to unsigned, a very large number