Converts between types using a combination of implicit and user-defined conversions.
static_cast < new_type > ( expression ) |
Returns a value of type new_type
.
Only the following conversions can be done with static_cast
, except when such conversions would cast away constness or volatility.
static_cast<new_type>(expression)
returns the imaginary variable Temp
initialized as if by new_type Temp(expression);
, which may involve implicit conversions, a call to the constructor of new_type or a call to a user-defined conversion operator. For non-reference new_type, the result object of the static_cast prvalue expression is what's direct-initialized (since C++17)
D
and the type of expression is a pointer or reference to its non-virtual base B
, static_cast
performs a downcast. This downcast is ill-formed if B
is ambiguous, inaccessible, or virtual base (or a base of a virtual base) of D
. Such static_cast
makes no runtime checks to ensure that the object's runtime type is actually D
, 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
. 3) If new_type is an rvalue reference type, static_cast converts the value of glvalue, class prvalue, or array prvalue (until C++17)any lvalue (since C++17) expression to xvalue referring to the same object as the expression, or to its base sub-object (depending on new_type). If the target type is an inaccessible or ambiguous base of the type of the expression, the program is ill-formed. If the expression is a bit field lvalue, it is first converted to prvalue of the underlying type. This type of static_cast is used to implement move semantics in std::move . | (since C++11) |
void
(possibly cv-qualified), static_cast
discards the value of expression after evaluating it.static_cast
can perform the inverse of that implicit conversion.static_cast
. When the target type is cv | (until C++20) |
The result is the same as implicit conversion from the enum's underlying type to the destination type. | (since C++20) |
D
can be upcast to a pointer to member of its unambiguous, accessible base class B
. This static_cast
makes no checks to ensure the member actually exists in the runtime type of the pointed-to object.void
(possibly cv-qualified) can be converted to pointer to any object type. If the original pointer value represents an address of a byte in memory that does not satisfy the alignment requirement of the target type, then the resulting pointer value is unspecified. Otherwise, if the original pointer value points to an object a, and there is an object b of the target type (ignoring cv-qualification) that is pointer-interconvertible (as defined below) with a, the result is a pointer to b. Otherwise the pointer value is unchanged. Conversion of any pointer to pointer to void and back to pointer to the original (or more cv-qualified) type preserves its original value.As with all cast expressions, the result is:
Two objects a and b are pointer-interconvertible if:
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"
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));
#include <vector> #include <iostream> struct B { int m = 0; void hello() const { std::cout << "Hello world, this is B!\n"; } }; struct D : B { void hello() const { std::cout << "Hello world, this is D!\n"; } }; enum class E { ONE = 1, TWO, THREE }; enum EU { ONE = 1, TWO, THREE }; int main() { // 1: initializing conversion int n = static_cast<int>(3.14); std::cout << "n = " << n << '\n'; std::vector<int> v = static_cast<std::vector<int>>(10); std::cout << "v.size() = " << v.size() << '\n'; // 2: static downcast D d; B& br = d; // upcast via implicit conversion br.hello(); D& another_d = static_cast<D&>(br); // downcast another_d.hello(); // 3: lvalue to xvalue std::vector<int> v2 = static_cast<std::vector<int>&&>(v); std::cout << "after move, v.size() = " << v.size() << '\n'; // 4: discarded-value expression static_cast<void>(v2.size()); // 5. inverse of implicit conversion void* nv = &n; int* ni = static_cast<int*>(nv); std::cout << "*ni = " << *ni << '\n'; // 6. array-to-pointer followed by upcast D a[10]; B* dp = static_cast<B*>(a); // 7. scoped enum to int or float E e = E::ONE; int one = static_cast<int>(e); std::cout << one << '\n'; // 8. int to enum, enum to another enum E e2 = static_cast<E>(one); EU eu = static_cast<EU>(e2); // 9. pointer to member upcast int D::*pm = &D::m; std::cout << br.*static_cast<int B::*>(pm) << '\n'; // 10. void* to any type void* voidp = &e; std::vector<int>* p = static_cast<std::vector<int>*>(voidp); }
Output:
n = 3 v.size() = 10 Hello world, this is B! Hello world, this is D! after move, v.size() = 0 *ni = 3 1 0
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
http://en.cppreference.com/w/cpp/language/static_cast