Converts between types using a combination of explicit and implicit conversions.
( new_type ) expression | (1) | |
new_type ( expression ) | (2) | |
new_type ( expressions ) | (3) | |
new_type ( ) | (4) | |
new_type { expression-list(optional) } | (5) | (since C++11) |
template-name ( expressions(optional) ) | (6) | (since C++17) |
template-name { expressions(optional) } | (7) | (since C++17) |
Returns a value of type new_type
.
const_cast<new_type>(expression)
;static_cast<new_type>(expression)
, with extensions: pointer or reference to a derived class is additionally allowed to be cast to pointer or reference to unambiguous base class (and vice versa) even if the base class is inaccessible (that is, this cast ignores the private inheritance specifier). Same applies to casting pointer to member to pointer to member of unambiguous non-virtual base;static_cast
(with extensions) followed by const_cast
;reinterpret_cast<new_type>(expression)
;reinterpret_cast
followed by const_cast
.static_cast
followed by a const_cast
, it cannot be compiled.unsigned int(expression)
or int*(expression)
are not valid), followed by a single expression in parentheses. This cast expression is exactly equivalent to the corresponding C-style cast expression.void
, the expression is a void prvalue without a result object (since C++17).void
, the expression is a void prvalue without a result object (since C++17).. This is the only cast expression that can create an array prvalue.As with all cast expressions, the result is:
double f = 3.14; unsigned int n1 = (unsigned int)f; // C-style cast unsigned int n2 = unsigned(f); // functional cast class C1; class C2; C2* foo(C1* p) { return (C2*)p; // casts incomplete type to incomplete type } // 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 }
const_cast conversion | adds or removes const |
static_cast conversion | performs basic conversions |
dynamic_cast conversion | performs checked polymorphic conversions |
reinterpret_cast conversion | performs general low-level conversions |
standard conversions | implicit conversions from one type to another |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/language/explicit_cast