Explicit type conversion

Converts between types using a combination of explicit and implicit conversions.

Syntax

Returns a value of type new-type.

Explanation

• If there is exactly one expression in parentheses, this cast expression is exactly equivalent to the corresponding C-style cast expression.
• If there are more than one expression or braced-init-list (since C++11) in parentheses, new-type must be a class with a suitably declared constructor. This expression is a prvalue of type new-type designating a temporary (until C++17)whose result object is (since C++17) direct-initialized with expression-list.
• If there's no expression in parentheses: if new-type names a non-array complete object type, this expression is a prvalue of type new-type, designating a temporary (until C++17)whose result object is (possibly with added cv-qualifiers) (since C++17) of that type. If new-type is an object type, the object is value-initialized. If new-type is (possibly cv-qualified) void, the expression is a void prvalue without a result object (since C++17).

As with all cast expressions, the result is:

• an lvalue if new-type is an lvalue reference type or an rvalue reference to function type (since C++11);

• a prvalue otherwise.

Ambiguity Resolution

In the case of an ambiguity between an expression statement with a function-style cast expression as its leftmost subexpression and a declaration statement, the ambiguity is resolved by treating it as a declaration. This disambiguation is purely syntactic: it does not consider the meaning of names occurring in the statement other than whether they are type names:

struct M {};
struct L { L(M&); };
 
M n;
void f()
{
    M(m);    // declaration, equivalent to M m;
    L(n);    // ill-formed declaration
    L(l)(m); // still a declaration
}

The ambiguity above can also occur in the context of a declaration. In that context, the choice is between an object declaration with a function-style cast as the initializer and a declaration involving a function declarator with a redundant set of parentheses around a parameter name. The resolution is also to consider any construct, such as the potential parameter declaration, that could possibly be a declaration to be a declaration:

struct S
{
    S(int);
};
 
void foo(double a)
{
    S w(int(a)); // function declaration: has a parameter `a` of type int
    S x(int());  // function declaration: has an unnamed parameter of type int(*)() 
                 // that is adjusted from int()
 
    // Ways to avoid ambiguity:
    S y((int(a))); // object declaration: extra pair of parentheses
    S y((int)a);   // object declaration: C-style cast
    S z = int(a);  // object declaration: no ambiguity for this syntax
}

An ambiguity can arise from the similarity between a function-style cast and a type-id. The resolution is that any construct that could possibly be a type-id in its syntactic context shall be considered a type-id:

// `int()` and `int(unsigned(a))` can both be parsed as type-id:
// `int()`            represents a function returning int
//                    and taking no argument
// `int(unsigned(a))` represents a function returning int
//                    and taking an argument of type unsigned
void foo(signed char a)
{
    sizeof(int());            // type-id (ill-formed)
    sizeof(int(a));           // expression
    sizeof(int(unsigned(a))); // type-id (ill-formed)
 
    (int()) + 1;            // type-id (ill-formed)
    (int(a)) + 1;           // expression
    (int(unsigned(a))) + 1; // type-id (ill-formed)
}

Notes

Example

#include <cassert>
#include <iostream>
 
double f = 3.14;
unsigned int n1 = (unsigned int)f; // C-style cast
unsigned int n2 = unsigned(f);     // function-style cast
 
class C1;
class C2;
C2* foo(C1* p)
{
    return (C2*)p; // casts incomplete type to incomplete type
}
 
void cpp23_decay_copy_demo()
{
    auto inc_print = [](int& x, const int& y)
    {
        ++x;
        std::cout << "x:" << x << ", y:" << y << '\n';
    };
 
    int p{1};
    inc_print(p, p); // prints x:2 y:2, because param y here is an alias of p
    int q{1};
    inc_print(q, auto{q}); // prints x:2 y:1, auto{q} (C++23) casts to prvalue,
                           // so the param y is a copy of q (not an alias of q)
}
 
// In this example, C-style cast is interpreted as static_cast
// even though it would work as reinterpret_cast
struct A {};
struct I1 : A {};
struct I2 : A {};
struct D : I1, I2 {};
 
int main()
{
    D* d = nullptr;
//  A* a = (A*)d;                   // compile-time error
    A* a = reinterpret_cast<A*>(d); // this compiles
    assert(a == nullptr);
 
    cpp23_decay_copy_demo();
}

x:2 y:2
x:2 y:1

Defect reports

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

References

• C++23 standard (ISO/IEC 14882:2023):
• 7.6.1.4 Explicit type conversion (functional notation) [expr.type.conv]
• 7.6.3 Explicit type conversion (cast notation) [expr.cast]
• C++20 standard (ISO/IEC 14882:2020):
• 7.6.1.4 Explicit type conversion (functional notation) [expr.type.conv]
• 7.6.3 Explicit type conversion (cast notation) [expr.cast]
• C++17 standard (ISO/IEC 14882:2017):
• 8.2.3 Explicit type conversion (functional notation) [expr.type.conv]
• 8.4 Explicit type conversion (cast notation) [expr.cast]
• C++14 standard (ISO/IEC 14882:2014):
• 5.2.3 Explicit type conversion (functional notation) [expr.type.conv]
• 5.4 Explicit type conversion (cast notation) [expr.cast]
• C++11 standard (ISO/IEC 14882:2011):
• 5.2.3 Explicit type conversion (functional notation) [expr.type.conv]
• 5.4 Explicit type conversion (cast notation) [expr.cast]
• C++03 standard (ISO/IEC 14882:2003):
• 5.2.3 Explicit type conversion (functional notation) [expr.type.conv]
• 5.4 Explicit type conversion (cast notation) [expr.cast]
• C++98 standard (ISO/IEC 14882:1998):
• 5.2.3 Explicit type conversion (functional notation) [expr.type.conv]
• 5.4 Explicit type conversion (cast notation) [expr.cast]

See also