static_cast преобразование

Выполняет преобразование между типами с помощью сочетания неявных и пользовательских преобразований.

Синтаксис

Возвращает значение типа target-type.

Пояснение

С помощью static_cast можно выполнять только следующие преобразования, за исключением случаев, когда такие преобразования снимают константность (или volatile-квалификатор).

• Derived является полным типом класса.
• Base является базовым классом Derived.
• Квалификация cv1 не выше квалификации cv2.

• Base является виртуальным базовым классом Derived.
• Base является базовым классом виртуального базового класса Derived.
• Не существует допустимого стандартного преобразования из «указателя на Derived» в «указатель на Base».

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

• преобразование lvalue в rvalue
• преобразование массива в указатель
• преобразование функции в указатель
• преобразование нулевого указателя
• преобразование нулевого указателя на член
• преобразование в bool

• Если у target-type задан фиксированный базовый тип, expression сначала преобразуется к этому типу с помощью целочисленного продвижения или целочисленного преобразования, если это необходимо, а затем — к target-type.
• Если у target-type не задан фиксированный базовый тип, значение expression не меняется, если исходное значение входит в диапазон значений перечисления; в противном случае поведение не определено.

• Derived является полным типом класса.
• Base является базовым классом Derived.
• Квалификация cv1 не выше квалификации cv2.

• Base является виртуальным базовым классом Derived.
• Base является базовым классом виртуального базового класса Derived.
• Не существует допустимого стандартного преобразования из «указателя на Derived» в «указатель на Base».

• Derived является полным типом класса.
• Base является базовым классом Derived.
• Квалификация cv1 не выше квалификации cv2.

Как и для всех выражений приведения, результат является:

• lvalue, если target-type является типом lvalue-ссылки или rvalue-ссылкой на тип функции(начиная с C++11);

• в противном случае — prvalue.

Объекты, взаимно преобразуемые через указатель

Два объекта a и b являются взаимно преобразуемыми через указатель, если:

• они являются одним и тем же объектом; или
• один из них является объектом объединения, а другой — нестатическим членом данных этого объекта; или
• один из них является объектом класса стандартного размещения, а другой — первым нестатическим членом данных этого объекта либо любым подобъектом базового класса этого объекта; или
• существует объект c, такой что a и c взаимно преобразуемы через указатель, а c и b взаимно преобразуемы через указатель.

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 не выполняют проверок во время выполнения, чтобы убедиться, что динамический тип объекта, на который указывает указатель или ссылка, — Derived. Их можно безопасно использовать, только если это предварительное условие гарантируется иным способом, например при реализации статического полиморфизма. Безопасное понижающее преобразование можно выполнить с помощью dynamic_cast.

static_cast также можно использовать для устранения неоднозначности перегрузок функций, преобразовав функцию в указатель на функцию определенного типа, как показано ниже:

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

Ключевые слова

static_cast

Пример

#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

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были ретроспективно применены к ранее опубликованным стандартам C++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2024):
• 7.6.1.9 Приведение static [expr.static.cast]
• Стандарт C++20 (ISO/IEC 14882:2020):
• 7.6.1.8 Приведение static [expr.static.cast]
• Стандарт C++17 (ISO/IEC 14882:2017):
• 8.2.9 Приведение static [expr.static.cast]
• Стандарт C++14 (ISO/IEC 14882:2014):
• 5.2.9 Приведение static [expr.static.cast]
• Стандарт C++11 (ISO/IEC 14882:2011):
• 5.2.9 Приведение static [expr.static.cast]
• Стандарт C++98 (ISO/IEC 14882:1998):
• 5.2.9 Приведение static [expr.static.cast]
• Стандарт C++03 (ISO/IEC 14882:2003):
• 5.2.9 Приведение static [expr.static.cast]

См. также

• const_cast
• dynamic_cast
• reinterpret_cast
• явное приведение
• неявные преобразования