# static_cast conversion

> C++ Atlas: `cppatlas.com/w/cpp/language/static_cast` | Source: https://en.cppreference.com/w/cpp/language/static_cast | Domain: Language | Standards: C++11, C++17, C++20, C++23

Converts between types using a combination of implicit and user-defined conversions.

## Official Specification Summary (cppreference)

Converts between types using a combination of implicit and user-defined conversions.

### Syntax

- `static_cast<`*target-type* `>(`*expression* `)`

Returns a value of type *target-type*.

### Explanation

Only the following conversions can be done with `static_cast`, except when such conversions would cast away constness (or volatility).

1) If *expression* is an lvalue of type “*cv1* `Base`” and *target-type* is “reference to *cv2* `Derived`”, the result refers to the object of type `Derived` enclosing *expression* if all following conditions are satisfied:

   - `Derived` is a complete class type.
   - `Base` is a base class of `Derived`.
   - *cv1* is not a greater cv-qualification than *cv2*.

If any of the following conditions is satisfied, the program is ill-formed:

   - `Base` is a virtual base class of `Derived`.
   - `Base` is a base class of a virtual base class of `Derived`.
   - No valid standard conversion from “pointer to `Derived`” to “pointer to `Base`” exists.

If *expression* is actually not a base class subobject of an object of type `Derived`, the behavior is undefined.

   ```cpp
   struct B {};
   struct D : B { B b; };

   D d;
   B& br1 = d;
   B& br2 = d.b;

   static_cast<D&>(br1); // OK, lvalue denoting the original “d” object
   static_cast<D&>(br2); // UB: the “b” subobject is not a base class subobject
   ```

(since C++11):

2) If *target-type* is “rvalue reference to `Derived`” and *expression* is an xvalue of type “(possibly cv-qualified) `Base`” such that `Base` is a base class of `Derived`, the result and constraints of such a conversion are the same as those of the “`Base` lvalue to `Derived` reference” conversion.

3) If *target-type* is an rvalue reference type and the referenced type is reference-compatible with the type of *expression*, `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 class subobject (depending on *target-type*).[1]

If *target-type* is an inaccessible or ambiguous base of the type of *expression*, the program is ill-formed.

If *expression* is a bit-field lvalue, it is first converted to prvalue of the underlying type.

4) If *target-type* is the (possibly cv-qualified) `void`, the conversion has no result. In this case, *expression* is a discarded-value expression.

5) Otherwise, *expression* can be explicitly converted to *target-type* if

   (until C++17):

   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).

   (since C++17):

   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.

   (since C++20):

   - *target-type* is an aggregate type having a first element `x` and there is an implicit conversion sequence from *expression* to the type of `x`.

   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*.

6) Otherwise, if the conversion from *expression* to *target-type* is an inverse of a standard conversion sequence, and the conversion sequence does not contain any of the following conversions, the conversion can be performed by `static_cast`:

   - lvalue-to-rvalue conversion
   - array-to-pointer conversion
   - function-to-pointer conversion
   - null pointer conversion
   - null member pointer conversion
   - boolean conversion

   (since C++17):

   - function pointer conversion

If a program uses `static_cast` to perform the inverse of an ill-formed standard conversion sequence, it is ill-formed.

7) Otherwise, lvalue-to-rvalue, array-to-pointer, and function-to-pointer conversions are applied to *expression*. After these conversions, only the following conversions can be performed by `static_cast`:

  a) A value of scoped enumeration type can be converted to an integer or floating-point type.

     (until C++20):

     - If *target-type* is (possibly cv-qualified) `bool`, the result is `false` if the original value of *expression* is zero and `true` for all other values.
     - If *target-type* is an integral type other than (possibly cv-qualified) `bool`, the value is unchanged if the original value of *expression* can be represented by *target-type*. Otherwise, the resulting value is unspecified.

     (since C++20):

     - If *target-type* is an integral type, the result is the same as that of converting to the enumeration’s underlying type and then to *target-type*.

     - If *target-type* is a floating-point type, the result is the same as that of converting from the original value to *target-type*. (since C++11)

  b) A value of integer or enumeration type can be converted to any complete enumeration type.

     - If *target-type* has a fixed underlying type, *expression* is first converted to that type by integral promotion or integral conversion, if necessary, and then to *target-type*.
     - If *target-type* does not have a fixed underlying type, the value of *expression* is unchanged if the original value is within the range of the enumeration values, otherwise the behavior is undefined.

  c) A value of a floating-point type can also be converted to any complete enumeration type. The result is the same as converting the original value of *expression* first to the underlying type of *target-type*, and then to *target-type* itself.

  d) A prvalue of floating-point type can be explicitly converted to any other floating-point type.

     - If the source value of *expression* can be represented exactly in *target-type*, it does not change.
     - Otherwise, if the source value of *expression* is between two representable values of *target-type*, the result of the conversion is an implementation-defined choice of either of those values.[2]
     - Otherwise, the behavior is undefined. (since C++23)

  e) An rvalue (until C++11) A prvalue (since C++11) of type “pointer to *cv1* `Base`” can be explicitly converted to the type “pointer to *cv2* `Derived`” if all following conditions are satisfied:

     - `Derived` is a complete class type.
     - `Base` is a base class of `Derived`.
     - *cv1* is not a greater cv-qualification than *cv2*.

  If *expression* is a null pointer value, the result is a null pointer value of type *target-type*. Otherwise, the result is a pointer to the object of type `Derived` enclosing the object of type `Base` pointed to by *expression*.

  If any of the following conditions is satisfied, the program is ill-formed:

     - `Base` is a virtual base class of `Derived`.
     - `Base` is a base class of a virtual base class of `Derived`.
     - No valid standard conversion from “pointer to `Derived`” to “pointer to `Base`” exists.

  If *expression* is not a null pointer value and does not actually point to a base class subobject of an object of type `Derived`, the behavior is undefined.

  f) An rvalue (until C++11) A prvalue (since C++11) of type “pointer to member of `Derived` of type *cv1* `T`” can be explicitly converted to the type “pointer to member of `Base` of type *cv2* `T`” if all following conditions are satisfied:

     - `Derived` is a complete class type.
     - `Base` is a base class of `Derived`.
     - *cv1* is not a greater cv-qualification than *cv2*.

  If *expression* is a null member pointer value, the result is a null member pointer value of type *target-type*. Otherwise, the result is a pointer to the original (possibly indirect) member of class `Base`.

  If no valid standard conversion from “pointer to member of `Base` of type `T`” to “pointer to member of `Derived` of type `T`” exists, the program is ill-formed.

  If *expression* is not a null member pointer value and the member it denotes is not a (possibly indirect) member of class `Base`, the behavior is undefined.

  g) An rvalue (until C++11) A prvalue (since C++11) of type “pointer to *cv1* `void`” can be explicitly converted to the type “pointer to *cv2* `T`” if `T` is an object type and *cv1* is not a greater cv-qualification than *cv2*.

     (until C++17):

     - If *expression* is a null pointer value, the result is a null pointer value of type *target-type*.
     - If the *expression* represents the address `A` of a byte in memory and `A` satisfies the alignment requirement of `T`, then the resulting pointer value also represents `A`.
     - The result of any other such pointer conversion is unspecified.
     - If *expression* the result of a prior conversion from an object of type “pointer to *cv3* `T`”, the result has the original value.

     (since C++17):

     - If *expression* represents the address `A` of a byte in memory but `A` does not satisfy the alignment requirement of `T`, then the resulting pointer value is unspecified.
     - Otherwise, if *expression* points to an object `a`, and there is an object `b` of type `T` (ignoring cv-qualification) that is pointer-interconvertible (see below) with `a`, the result is a pointer to `b`.
     - Otherwise, the pointer value is unchanged by the conversion.

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);

(since C++11):

- an xvalue if *target-type* is an rvalue reference to object type;

- 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.

### 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.

```cpp
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”
```

### 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

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

### Keywords

`static_cast`

### Example

```cpp
#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);
}
```

Output:

```text
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
```

### Defect reports

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

| DR | Applied to | Behavior as published | Correct behavior |
| --- | --- | --- | --- |
| CWG 137 | C++98 | the constness and volatility of pointers to `void` could be casted away | cv-qualifications cannot be casted away in such cases |
| CWG 427 | C++98 | downcast might be ambiguous with direct-initialization | selects downcast in this case |
| CWG 439 | C++98 | when converting a “pointer to object” to “pointer to `void`” then back to itself, it could only preserve its value if the result type has the same cv-qualification | cv-qualification may be different |
| CWG 1094 | C++98 | the conversion from floating-point values to enumeration values was unspecified | specified |
| CWG 1320 | C++11 | the conversion from scoped enumeration values to bool was unspecified | specified |
| CWG 1412 | C++98 | the result of the conversion from “pointer to `void`” to “pointer to object” was unclear | made clear |
| CWG 1447 | C++11 | the conversion from bit-fields to rvalue references was unspecified (cannot bind references to bit-fields) | specified |
| CWG 1766 | C++98 | the conversion from integral or enumeration values to enumeration values yielded unspecified result if *expression* is out of range | the behavior is undefined in this case |
| CWG 1832 | C++98 | the conversion from integral or enumeration values to enumeration values allowed *target-type* to be incomplete | not allowed |
| CWG 2224 | C++98 | the conversion from a member of base class type to its complete object of derived class type was valid | the behavior is undefined in this case |
| CWG 2254 | C++11 | a standard-layout class object with no data members was pointer-interconvertible to its first base class | it is pointer-interconvertible to any of its base classes |
| CWG 2284 | C++11 | a non-standard-layout union object and a non-static data member of that object were not pointer-interconvertible | they are |
| CWG 2310 | C++98 | for base-to-derived pointer conversions and derived-to-base pointer-to-member conversions, the derived class type could be incomplete | must be complete |
| CWG 2338 | C++11 | the conversion to enumeration types with fixed underlying type resulted in undefined behavior if *expression* is out of range | convert to the underlying type first (no undefined behavior) |
| CWG 2499 | C++11 | a standard-layout class might have a non-pointer-interconvertible base class, even though all base subobjects have the same address | it does not have |
| CWG 2718 | C++98 | for base-to-derived reference conversions, the derived class type could be incomplete | must be complete |
| CWG 2882 | C++98 | it was unclear whether `static_cast<void>(expr)` attempts to form an implicit conversion sequence from `expr` to `void` | no attempt in this case |

### References

- C++23 standard (ISO/IEC 14882:2024):

  - 7.6.1.9 Static cast [expr.static.cast]

- C++20 standard (ISO/IEC 14882:2020):

  - 7.6.1.8 Static cast [expr.static.cast]

- C++17 standard (ISO/IEC 14882:2017):

  - 8.2.9 Static cast [expr.static.cast]

- C++14 standard (ISO/IEC 14882:2014):

  - 5.2.9 Static cast [expr.static.cast]

- C++11 standard (ISO/IEC 14882:2011):

  - 5.2.9 Static cast [expr.static.cast]

- C++98 standard (ISO/IEC 14882:1998):

  - 5.2.9 Static cast [expr.static.cast]

- C++03 standard (ISO/IEC 14882:2003):

  - 5.2.9 Static cast [expr.static.cast]

### See also

- [`const_cast`](https://en.cppreference.com/w/cpp/language/const_cast)
- [`dynamic_cast`](https://en.cppreference.com/w/cpp/language/dynamic_cast)
- [`reinterpret_cast`](https://en.cppreference.com/w/cpp/language/reinterpret_cast)
- [explicit cast](https://en.cppreference.com/w/cpp/language/explicit_cast)
- [implicit conversions](https://en.cppreference.com/w/cpp/language/implicit_conversion)

---
Attribution: content from https://en.cppreference.com/w/cpp/language/static_cast (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.