7 Standard conversions [conv]

7.5 Qualification conversions [conv.qual]

A cv-decomposition of a type T is a sequence of

c v_{i}

and

P_{i}

such that T is “

c v_{0}

P_{0}

c v_{1}

P_{1}

⋯

c v_{n - 1}

P_{n - 1}

c v_{n}

U” for

n > 0

, where each

c v_{i}

is a set of cv-qualifiers ([basic.type.qualifier]), and each

P_{i}

is “pointer to” ([dcl.ptr]), “pointer to member of class

C_{i}

of type” ([dcl.mptr]), “array of

N_{i}

”, or “array of unknown bound of” ([dcl.array]).

P_{i}

designates an array, the cv-qualifiers

c v_{i + 1}

on the element type are also taken as the cv-qualifiers

c v_{i}

of the array.

[ Example

The type denoted by the type-id const int ** has two cv-decompositions, taking U as “int” and as “pointer to const int”.

— end example

]

The n-tuple of cv-qualifiers after the first one in the longest cv-decomposition of T, that is,

c v_{1}, c v_{2}, \dots, c v_{n}

, is called the cv-qualification signature of T.

Two types T

_{1}

and T

_{2}

are similar if they have cv-decompositions with the same n such that corresponding

P_{i}

components are the same and the types denoted by U are the same.

A prvalue expression of type T

_{1}

can be converted to type T

_{2}

if the following conditions are satisfied, where

c v_{i}^{j}

denotes the cv-qualifiers in the cv-qualification signature of T

_{j}

:60

(3.1)
T $_{1}$ and T $_{2}$ are similar.
(3.2)
For every $i > 0$ , if const is in ${c v}_{i}^{1}$ then const is in ${c v}_{i}^{2}$ , and similarly for volatile.
(3.3)
If the ${c v}_{i}^{1}$ and ${c v}_{i}^{2}$ are different, then const is in every ${c v}_{k}^{2}$ for $0 < k < i$ .

[ Note

If a program could assign a pointer of type T** to a pointer of type const T** (that is, if line #1 below were allowed), a program could inadvertently modify a const object (as it is done on line #2).

For example,

int main() {
  const char c = 'c';
  char* pc;
  const char** pcc = &pc;       // #1: not allowed
  *pcc = &c;
  *pc = 'C';                    // #2: modifies a const object
}

— end note

]

[ Note

A prvalue of type “pointer to cv1 T” can be converted to a prvalue of type “pointer to cv2 T” if “cv2 T” is more cv-qualified than “cv1 T”.

A prvalue of type “pointer to member of X of type cv1 T” can be converted to a prvalue of type “pointer to member of X of type cv2 T” if “cv2 T” is more cv-qualified than “cv1 T”.

— end note

]

[ Note

Function types (including those used in pointer to member function types) are never cv-qualified ([dcl.fct]).

— end note

]

60)

These rules ensure that const-safety is preserved by the conversion.