6 Basic concepts [basic]

Compound types can be constructed in the following ways:

• (1.1)

  arrays of objects of a given type, [dcl.array];

• (1.2)

  functions, which have parameters of given types and return void or references or objects of a given type, [dcl.fct];

• (1.3)

  pointers to cv void or objects or functions (including static members of classes) of a given type, [dcl.ptr];

• (1.4)

  references to objects or functions of a given type, [dcl.ref]. There are two types of references:

  • (1.4.1)

    lvalue reference

  • (1.4.2)

    rvalue reference

• (1.5)

  classes containing a sequence of objects of various types (Clause [class]), a set of types, enumerations and functions for manipulating these objects ([class.mfct]), and a set of restrictions on the access to these entities (Clause [class.access]);

• (1.6)

  unions, which are classes capable of containing objects of different types at different times, [class.union];

• (1.7)

  enumerations, which comprise a set of named constant values. Each distinct enumeration constitutes a different enumerated type, [dcl.enum];

• (1.8)

  pointers to non-static class members,53 which identify members of a given type within objects of a given class, [dcl.mptr].

These methods of constructing types can be applied recursively; restrictions are mentioned in [dcl.ptr], [dcl.array], [dcl.fct], and [dcl.ref]. Constructing a type such that the number of bytes in its object representation exceeds the maximum value representable in the type std​::​size_­t ([support.types]) is ill-formed.

The type of a pointer to cv void or a pointer to an object type is called an object pointer type. [ Note: A pointer to void does not have a pointer-to-object type, however, because void is not an object type.  — end note ] The type of a pointer that can designate a function is called a function pointer type. A pointer to objects of type T is referred to as a “pointer to T”. [ Example: A pointer to an object of type int is referred to as “pointer to int” and a pointer to an object of class X is called a “pointer to X”.  — end example ] Except for pointers to static members, text referring to “pointers” does not apply to pointers to members. Pointers to incomplete types are allowed although there are restrictions on what can be done with them ([basic.align]). Every value of pointer type is one of the following:

• (3.1)

  a pointer to an object or function (the pointer is said to point to the object or function), or

• (3.2)

  a pointer past the end of an object ([expr.add]), or

• (3.3)

  the null pointer value ([conv.ptr]) for that type, or

• (3.4)

  an invalid pointer value.

A value of a pointer type that is a pointer to or past the end of an object represents the address of the first byte in memory ([intro.memory]) occupied by the object54 or the first byte in memory after the end of the storage occupied by the object, respectively. [ Note: A pointer past the end of an object ([expr.add]) is not considered to point to an unrelated object of the object's type that might be located at that address. A pointer value becomes invalid when the storage it denotes reaches the end of its storage duration; see [basic.stc].  — end note ] For purposes of pointer arithmetic and comparison ([expr.rel], [expr.eq]), a pointer past the end of the last element of an array x of n elements is considered to be equivalent to a pointer to a hypothetical element x[n]. The value representation of pointer types is implementation-defined. Pointers to layout-compatible types shall have the same value representation and alignment requirements. [ Note: Pointers to over-aligned types have no special representation, but their range of valid values is restricted by the extended alignment requirement. — end note ]

Two objects a and b are pointer-interconvertible if:

• (4.1)

  they are the same object, or

• (4.2)

  one is a standard-layout union object and the other is a non-static data member of that object ([class.union]), or

• (4.3)

  one is a standard-layout class object and the other is the first non-static data member of that object, or, if the object has no non-static data members, the first base class subobject of that object ([class.mem]), or

• (4.4)

  there exists an object c such that a and c are pointer-interconvertible, and c and b are pointer-interconvertible.

If two objects are pointer-interconvertible, then they have the same address, and it is possible to obtain a pointer to one from a pointer to the other via a reinterpret_­cast. [ Note: An array object and its first element are not pointer-interconvertible, even though they have the same address.  — end note ]

A pointer to cv-qualified or cv-unqualified void can be used to point to objects of unknown type. Such a pointer shall be able to hold any object pointer. An object of type cv void* shall have the same representation and alignment requirements as cv char*.