static_cast conversion

the declaration target-type temp(expression ); is well-formed for some invented temporary variable temp.

The effect of such an explicit conversion is the same as performing the declaration and initialization and then using temp as the result of the conversion. The expression  is used as an lvalue(until C++11)a glvalue(since C++11) if and only if the initialization uses it as an lvalue(until C++11)a glvalue(since C++11).

any of the following conditions is satisfied:

• There is an implicit conversion sequence from expression to target-type.
• The overload resolution for a direct-initialization of an object or reference of type target-type from expression would find at least one viable function.

The explicit conversion is defined as follows:

• If target-type is a reference type, the effect is the same as performing the declaration and initialization target-type temp(expression ); for some invented temporary variable temp and then using temp as the result of the conversion.
• Otherwise, the result object is direct-initialized from expression .

As with all cast expressions, the result is:

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

• a prvalue otherwise.

1. ↑ This type of static_cast is used to implement move semantics in std::move.
2. ↑ If IEEE arithmetic is supported, rounding defaults to nearest.

[edit] Pointer-interconvertible objects

Two objects a and b are pointer-interconvertible if:

• they are the same object, or
• one is a union object and the other is a non-static data member of that object, or
• one is a standard-layout class object and the other is the first non-static data member of that object or any base class subobject of that object, or
• there exists an object c such that a and c are pointer-interconvertible, and c and b are pointer-interconvertible.

union U { int a; double b; } u;
void* x = &u; // x's value is "pointer to u"
double* y = static_cast<double*>(x); // y's value is "pointer to u.b"
char* z = static_cast<char*>(x); // z's value is "pointer to u"

[edit] Notes

Base-to-derived conversions (downcasts) using static_cast make no runtime checks to ensure that the dynamic type of the pointed/referred object is Derived, and may only be used safely if this precondition is guaranteed by other means, such as when implementing static polymorphism. Safe downcast may be done with dynamic_cast.

static_cast may also be used to disambiguate function overloads by performing a function-to-pointer conversion to specific type, as in

std::for_each (files.begin(), files.end(),
 static_cast<std::ostream &(*)(std::ostream &)>(std::flush ));

[edit] Keywords

static_cast

[edit] Example

#include <iostream>
#include <vector>
 
struct B
{
 int m = 42;
 const char* hello() const
 {
 return "Hello world, this is B!\n";
 }
};
 
struct D : B
{
 const char* hello() const
 {
 return "Hello world, this is D!\n";
 }
};
 
enum class E { ONE = 1, TWO, THREE };
enum EU { ONE = 1, TWO, THREE };
 
int main()
{
 // 1. static downcast
 D d;
 B& br = d; // upcast via implicit conversion
 std::cout << "1) " << br.hello();
 D& another_d = static_cast<D&>(br); // downcast
 std::cout << "1) " << another_d.hello();
 
 // 3. lvalue to xvalue
 std::vector <int> v0{1, 2, 3};
 std::vector <int> v2 = static_cast<std::vector <int>&&>(v0);
 std::cout << "3) after move, v0.size() = " << v0.size() << '\n';
 
 // 4. discarded-value expression
 static_cast<void>(v2.size());
 
 // 5. initializing conversion
 int n = static_cast<int>(3.14);
 std::cout << "5) n = " << n << '\n';
 std::vector <int> v = static_cast<std::vector <int>>(10);
 std::cout << "5) v.size() = " << v.size() << '\n';
 
 // 6. inverse of implicit conversion
 void* nv = &n;
 int* ni = static_cast<int*>(nv);
 std::cout << "6) *ni = " << *ni << '\n';
 
 // 7a. scoped enum to int
 E e = E::TWO;
 int two = static_cast<int>(e);
 std::cout << "7a) " << two << '\n';
 
 // 7b. int to enum, enum to another enum
 E e2 = static_cast<E>(two);
 [[maybe_unused]]
 EU eu = static_cast<EU>(e2);
 
 // 7f. pointer to member upcast
 int D::*pm = &D::m;
 std::cout << "7f) " << br.*static_cast<int B::*>(pm) << '\n';
 
 // 7g. void* to any object pointer
 void* voidp = &e;
 [[maybe_unused]]
 std::vector <int>* p = static_cast<std::vector <int>*>(voidp);
}

1) Hello world, this is B!
1) Hello world, this is D!
3) after move, v0.size() = 0
5) n = 3
5) v.size() = 10
6) *ni = 3
7a) 2
7f) 42

[edit] Defect reports

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

[edit] References

[edit] See also

• const_cast
• dynamic_cast
• reinterpret_cast
• explicit cast
• implicit conversions