Implicit conversions are performed whenever an expression of some typeT1 is used in context that does not accept that type, but accepts some other typeT2; in particular:

• when the expression is used as the argument when calling a function that is declared withT2 as parameter;
• when the expression is used as an operand with an operator that expectsT2;
• when initializing a new object of typeT2, includingreturn statement in a function returningT2;
• when the expression is used in aswitch statement (T2 is integral type);
• when the expression is used in anif statement or a loop (T2 isbool).

The program is well-formed (compiles) only if there exists one unambiguousimplicit conversion sequence fromT1 toT2.

If there are multiple overloads of the function or operator being called, after the implicit conversion sequence is built fromT1 to each availableT2,overload resolution rules decide which overload is compiled.

Note: in arithmetic expressions, the destination type for the implicit conversions on the operands to binary operators is determined by a separate set of rules:usual arithmetic conversions.

[edit]Order of the conversions

Implicit conversion sequence consists of the following, in this order:

When considering the argument to a constructor or to a user-defined conversion function, only one standard conversion sequence is allowed (otherwise user-defined conversions could be effectively chained). When converting from one non-class type to another non-class type, only a standard conversion sequence is allowed.

A standard conversion sequence consists of the following, in this order:

A user-defined conversion consists of zero or one non-explicit single-argumentconverting constructor or non-explicitconversion function call.

An expressione is said to beimplicitly convertible toT2 if and only ifT2 can becopy-initialized frome, that is the declarationT2 t= e; is well-formed (can be compiled), for some invented temporaryt. Note that this is different fromdirect initialization (T2 t(e)), where explicit constructors and conversion functions would additionally be considered.

[edit]Contextual conversions

In the following contexts, a context-specific typeT is expected, and the expressione of class typeE is only allowed if

Such expressione is said to becontextually implicitly converted to the specified typeT.Note that explicit conversion functions are not considered, even though they are considered in contextual conversions tobool.(since C++11)

• the argument of thedelete-expression (T is any object pointer type);
• integral constant expression, where a literal class is used (T is any integral or unscoped enumeration type, the selected user-defined conversion function must beconstexpr);
• the controlling expression of theswitch statement (T is any integral or enumeration type).

#include <cassert> template<typename T>class zero_init{    T val;public:    zero_init(): val(static_cast<T>(0)){}    zero_init(T val): val(val){}    operator T&(){return val;}    operator T()const{return val;}}; int main(){    zero_init<int> i;assert(i==0);     i=7;assert(i==7); switch(i){}// error until C++14 (more than one conversion function)// OK since C++14 (both functions convert to the same type int)switch(i+0){}// always okay (implicit conversion)}

[edit]Value transformations

Value transformations are conversions that change thevalue category of an expression. They take place whenever an expression appears as an operand of an operator that expects an expression of a different value category:

• Whenever a glvalue appears as an operand of an operator that requires a prvalue for that operand, thelvalue-to-rvalue,array-to-pointer, orfunction-to-pointer standard conversions are applied to convert the expression to a prvalue.

[edit]Lvalue-to-rvalue conversion

Anlvalue(until C++11)Aglvalue(since C++11) of any non-function, non-array typeT can be implicitly converted toanrvalue(until C++11)aprvalue(since C++11):

• IfT is not a class type, the type of thervalue(until C++11)prvalue(since C++11) is the cv-unqualified version ofT.
• Otherwise, the type of thervalue(until C++11)prvalue(since C++11) isT.

If an lvalue-to-rvalue conversion from anincomplete type is required by a program, that program is ill-formed.

Given the object to which thelvalue(until C++11)glvalue(since C++11) refers asobj:

This conversion models the act of reading a value from a memory location into a CPU register.

[edit]Array-to-pointer conversion

Anlvalue orrvalue of type “array ofNT” or “array of unknown bound ofT” can be implicitly converted to aprvalue of type “pointer toT”.If the array is a prvalue,temporary materialization occurs.(since C++17) The resulting pointer refers to the first element of the array (seeArray-to-pointer decay for details).

[edit]Function-to-pointer conversion

Anlvalue of function type can be implicitly converted to aprvaluepointer to that function. This does not apply to non-static member functions because lvalues that refer to non-static member functions do not exist.

struct S{int m;};int i= S().m;// member access expects glvalue as of C++17;// S() prvalue is converted to xvalue

[edit]Integral promotion

prvalues of small integral types (such aschar) and unscoped enumeration types may be converted to prvalues of larger integral types (such asint). In particular,arithmetic operators do not accept types smaller thanint as arguments, and integral promotions are automatically applied after lvalue-to-rvalue conversion, if applicable. This conversion always preserves the value.

The following implicit conversions in this section are classified asintegral promotions.

Note that for a given source type, the destination type of integral promotion is unique, And all other conversions are not promotions. For example,overload resolution chooseschar ->int (promotion) overchar ->short (conversion).

[edit]Promotion from integral types

A prvalue of typebool can be converted to a prvalue of typeint, withfalse becoming​0​ andtrue becoming1.

For a prvalueval of an integral typeT exceptbool:

[edit]Promotion from enumeration types

A prvalue of an unscopedenumeration type whose underlying type is not fixed can be converted to a prvalue of the first type from the following list able to hold their entire value range:

• int
• unsignedint
• long
• unsignedlong

[edit]Floating-point promotion

Aprvalue of typefloat can be converted to a prvalue of typedouble. The value does not change.

This conversion is calledfloating-point promotion.

[edit]Numeric conversions

Unlike the promotions, numeric conversions may change the values, with potential loss of precision.

[edit]Integral conversions

Aprvalue of an integer type or of an unscoped enumeration type can be converted to any other integer type. If the conversion is listed under integral promotions, it is a promotion and not a conversion.

• If the destination type is unsigned, the resulting value is the smallest unsigned value equal to the source valuemodulo2n
  wheren is the number of bits used to represent the destination type.

• That is, depending on whether the destination type is wider or narrower, signed integers are sign-extended^[1] or truncated and unsigned integers are zero-extended or truncated respectively.

• If the destination type is signed, the value does not change if the source integer can be represented in the destination type. Otherwise the result isimplementation-defined(until C++20)the unique value of the destination type equal to the source value modulo2n
  wheren is the number of bits used to represent the destination type(since C++20) (note that this is different fromsigned integer arithmetic overflow, which is undefined).
• If the source type isbool, the valuefalse is converted to zero and the valuetrue is converted to the value one of the destination type (note that if the destination type isint, this is an integer promotion, not an integer conversion).
• If the destination type isbool, this is aboolean conversion (see below).

1. ↑This only applies if the arithmetic is two's complement which is only required for theexact-width integer types. Note, however, that at the moment all platforms with a C++ compiler use two's complement arithmetic.

[edit]Floating-point conversions

If the conversion is listed under floating-point promotions, it is a promotion and not a conversion.

• If the source value can be represented exactly in the destination type, it does not change.
• If the source value is between two representable values of the destination type, the result is one of those two values (it is implementation-defined which one, although if IEEE arithmetic is supported, rounding defaultsto nearest).
• Otherwise, the behavior is undefined.

[edit]Floating–integral conversions

Aprvalue of floating-point type can be converted to a prvalue of any integer type. The fractional part is truncated, that is, the fractional part is discarded.

• If the truncated value cannot fit into the destination type, the behavior is undefined (even when the destination type is unsigned, modulo arithmetic does not apply).
• If the destination type isbool, this is a boolean conversion (seebelow).

A prvalue of integer or unscoped enumeration type can be converted to a prvalue of any floating-point type. The result is exact if possible.

• If the value can fit into the destination type but cannot be represented exactly, it is implementation defined whether the closest higher or the closest lower representable value will be selected, although if IEEE arithmetic is supported, rounding defaultsto nearest.
• If the value cannot fit into the destination type, the behavior is undefined.
• If the source type isbool, the valuefalse is converted to zero, and the valuetrue is converted to one.

[edit]Pointer conversions

Anull pointer constant can be converted to any pointer type, and the result is the null pointer value of that type. Such conversion (known asnull pointer conversion) is allowed to convert to a cv-qualified type as a single conversion, that is, it is not considered a combination of numeric and qualifying conversions.

Aprvalue pointer to any (optionally cv-qualified) object typeT can be converted to a prvalue pointer to (identically cv-qualified)void. The resulting pointer represents the same location in memory as the original pointer value.

• If the original pointer is a null pointer value, the result is a null pointer value of the destination type.

A prvalueptr of type “pointer to (possibly cv-qualified)Derived” can be converted to a prvalue of type “pointer to (possibly cv-qualified)Base”, whereBase is abase class ofDerived, andDerived is acomplete class type. If theBase is inaccessible or ambiguous, the program is ill-formed.

• Ifptr is a null pointer value, the result is also a null pointer value.
• Otherwise, ifBase is avirtual base class ofDerived andptr does not point to an object whose type issimilar toDerived and that is within itslifetime or within its period of construction or destruction, the behavior is undefined.
• Otherwise, the result is a pointer to the base class subobject of the derived class object.

[edit]Pointer-to-member conversions

Anull pointer constant can be converted to any pointer-to-member type, and the result is the null member pointer value of that type. Such conversion (known asnull member pointer conversion) is allowed to convert to a cv-qualified type as a single conversion, that is, it is not considered a combination of numeric and qualifying conversions.

Aprvalue of type “pointer to member ofBase of type (possibly cv-qualified)T” can be converted to a prvalue of type “pointer to member ofDerived of type (identically cv-qualified)T”, whereBase is a base class ofDerived, andDerived is a complete class type. IfBase is inaccessible, ambiguous, or virtual base ofDerived or is a base of some intermediate virtual base ofDerived, the program is ill-formed.

• IfDerived does not contain the original member and is not a base class of the class containing the original member, the behavior is undefined.
• Otherwise, the resulting pointer can be dereferenced with aDerived object, and it will access the member within theBase base subobject of thatDerived object.

[edit]Boolean conversions

Aprvalue of integral, floating-point, unscoped enumeration, pointer, and pointer-to-member types can be converted to a prvalue of typebool.

The value zero (for integral, floating-point, and unscoped enumeration) and the null pointer and the null pointer-to-member values becomefalse. All other values becometrue.

[edit]Qualification conversions

Generally speaking:

• Aprvalue of type pointer tocv-qualified typeT can be converted to a prvalue pointer to a more cv-qualified same typeT (in other words, constness and volatility can be added).
• A prvalue of type pointer to member of cv-qualified typeT in classX can be converted to a prvalue pointer to member ofmore cv-qualified typeT in classX.

The formal definition of “qualification conversion” is givenbelow.

[edit]Similar types

Informally, two types aresimilar if, ignoring top-level cv-qualification:

• they are the same type; or
• they are both pointers, and the pointed-to types are similar; or
• they are both pointers to member of the same class, and the types of the pointed-to members are similar; or
• they are both arrays and the array element types are similar.

For example:

• constint*const* andint** are similar;
• int(*)(int*) andint(*)(constint*) are not similar;
• constint(*)(int*) andint(*)(int*) are not similar;
• int(*)(int*const) andint(*)(int*) are similar (they are the same type);
• std::pair<int,int> andstd::pair<constint,int> are not similar.

Formally, type similarity is defined in terms of qualification-decomposition.

Aqualification-decomposition of a typeT is a sequence of componentscv_i andP_i such thatT is “cv_0 P_0 cv_1 P_1 ... cv_n−1 P_n−1 cv_n U” for non-negativen, where

• eachcv_i is a set ofconst andvolatile, and
• eachP_i is

• “pointer to”,
• “pointer to member of classC_i of type”,
• “array ofN_i”, or
• “array of unknown bound of”.

IfP_i designates an array, the cv-qualifierscv_i+1 on the element type are also taken as the cv-qualifierscv_i of the array.

// T is “pointer to pointer to const int”, it has 3 qualification-decompositions:// n = 0 -> cv_0 is empty, U is “pointer to pointer to const int”// n = 1 -> cv_0 is empty, P_0 is “pointer to”,//          cv_1 is empty, U is “pointer to const int”// n = 2 -> cv_0 is empty, P_0 is “pointer to”,//          cv_1 is empty, P_1 is “pointer to”,//          cv_2 is “const", U is “int”using T=constint**; // substitute any of the following type to U gives one of the decompositions:// U = U0 -> the decomposition with n = 0: U0// U = U1 -> the decomposition with n = 1: pointer to [U1]// U = U2 -> the decomposition with n = 2: pointer to [pointer to [const U2]]using U2=int;using U1=const U2*;using U0= U1*;

Two typesT1 andT2 aresimilar if there exists a qualification-decomposition for each of them, where all following conditions are satisfied for the two qualification-decompositions:

• They have the samen.
• The types denoted byU are the same.
• The correspondingP_i components are the sameor one is “array ofN_i” and the other is “array of unknown bound of”(since C++20) for alli.

// the qualification-decomposition with n = 2:// pointer to [volatile pointer to [const int]]using T1=constint*volatile*; // the qualification-decomposition with n = 2:// const pointer to [pointer to [int]]using T2=int**const; // For the two qualification-decompositions above// although cv_0, cv_1 and cv_2 are all different,// they have the same n, U, P_0 and P_1,// therefore types T1 and T2 are similar.

[edit]Combining cv-qualifications

In the description below, the longest qualification-decomposition of typeTn is denoted asDn, and its components are denoted ascvn_i andPn_i.

// longest qualification-decomposition of T1 (n = 2):// pointer to [pointer to [char]]using T1=char**; // longest qualification-decomposition of T2 (n = 2):// pointer to [pointer to [const char]]using T2=constchar**; // Determining the cv3_i and T_i components of D3 (n = 2):// cv3_1 = empty (union of empty cv1_1 and empty cv2_1)// cv3_2 = “const” (union of empty cv1_2 and “const” cv2_2)// P3_0 = “pointer to” (no array of unknown bound, use P1_0)// P3_1 = “pointer to” (no array of unknown bound, use P1_1)// All components except cv_2 are the same, cv3_2 is different from cv1_2,// therefore add “const” to cv3_k for each k in [1, 2): cv3_1 becomes “const”.// T3 is “pointer to const pointer to const char”, i.e., const char* const *.using T3=/* the qualification-combined type of T1 and T2 */; int main(){constchar c='c';char* pc;    T1 ppc=&pc;    T2 pcc= ppc;// Error: T3 is not the same as cv-unqualified T2,//        no implicit conversion. *pcc=&c;*pc='C';// If the erroneous assignment above is allowed,// the const object “c” may be modified.}

Note that in the C programming language,const/volatile can be added to the first level only:

char** p=0;char*const* p1= p;// OK in C and C++constchar*const* p2= p;// error in C, OK in C++

void(*p)();void(**pp)()noexcept=&p;// error: cannot convert to pointer to noexcept function struct S{typedefvoid(*p)();    operator p();};void(*q)()noexcept= S();// error: cannot convert to pointer to noexcept function

[edit]The safe bool problem

Until C++11, designing a class that should be usable in boolean contexts (e.g.if(obj){ ...}) presented a problem: given a user-defined conversion function, such asT::operatorbool()const;, the implicit conversion sequence allowed one additional standard conversion sequence after that function call, which means the resultantbool could be converted toint, allowing such code asobj<<1; orint i= obj;.

One early solution for this can be seen instd::basic_ios, which initially definesoperatorvoid*, so that the code such asif(std::cin){...} compiles becausevoid* is convertible tobool, butint n=std::cout; does not compile becausevoid* is not convertible toint. This still allows nonsense code such asdeletestd::cout; to compile.

Many pre-C++11 third party libraries were designed with a more elaborate solution, known as theSafe Bool idiom.std::basic_ios also allowed this idiom viaLWG issue 468, andoperatorvoid* was replaced (seenotes).

Since C++11,explicit bool conversion can also be used to resolve the safe bool problem.

[edit]Defect reports

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

[edit]See also

• const_cast
• static_cast
• dynamic_cast
• reinterpret_cast
• explicit cast
• user-defined conversion

• In other languages

• Deutsch
• Español
• Français
• Italiano
• 日本語
• Português
• Русский
• 中文