Explicit type conversions

Introduction

An expression can be explicitly converted or cast to type T using dynamic_cast<T>, static_cast<T>, reinterpret_cast<T>, or const_cast<T>, depending on what type of cast is intended.

C++ also supports function-style cast notation, T(expr), and C-style cast notation, (T)expr.

Syntax

• simple-type-specifier \( \)
• simple-type-specifier \( expression-list \)
• simple-type-specifier braced-init-list
• typename-specifier \( \)
• typename-specifier \( expression-list \)
• typename-specifier braced-init-list
• dynamic_cast \< type-id \> \( expression \)
• static_cast \< type-id \> \( expression \)
• reinterpret_cast \< type-id \> \( expression \)
• const_cast \< type-id \> \( expression \)
• \( type-id \) cast-expression

Remarks

All six cast notations have one thing in common:

• Casting to an lvalue reference type, as in dynamic_cast<Derived&>(base), yields an lvalue. Therefore, when you want to do something with the same object but treat it as a different type, you would cast to an lvalue reference type.
• Casting to an rvalue reference type, as in static_cast<string&&>(s), yields an rvalue.
• Casting to a non-reference type, as in (int)x, yields a prvalue, which may be thought of as a copy of the value being cast, but with a different type from the original.

The reinterpret_cast keyword is responsible for performing two different kinds of “unsafe” conversions:

• The “type punning” conversions, which can be used to access memory of one type as though it is of a different type.
• Conversions between integer types and pointer types, in either direction.

The static_cast keyword can perform a variety of different conversions:

• Base to derived conversions
• Any conversion that can be done by a direct initialization, including both implicit conversions and conversions that call an explicit constructor or conversion function. See here and here for more details.
• To void, which discards the value of the expression.

// on some compilers, suppresses warning about x being unused
static_cast<void>(x);

• Between arithmetic and enumeration types, and between different enumeration types. See enum conversions
• From pointer to member of derived class, to pointer to member of base class. The types pointed to must match. See derived to base conversion for pointers to members
• void* to T*.
• From an lvalue to an xvalue, as in std::move. See move semantics.