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

Преобразует типы с использованием комбинации неявных и определяемых пользователем преобразований.

Синтаксис

Возвращает значение типа тип-результата.

Объяснение

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

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

• Если базовый тип не фиксирован, поведение неопределено, если значение выражение выходит за пределы диапазона (диапазон включает все значения, возможные для самого маленького поля бит, достаточно большого, чтобы содержать все перечислители целевого перечисления).
• Если базовый тип фиксирован, результат такой же, как преобразование исходного значения сначала в базовый тип перечисления, а затем в тип перечисления.

• Результат совпадает с преобразованием исходного значения сначала в базовый тип перечисления, а затем в тип перечисления.

• Если исходное значение указателя представляет адрес байта в памяти, который не удовлетворяет требованию выравнивания T, то результирующее значение указателя является неопределённым.
• В противном случае, если исходный указатель указывает на объект a, и существует объект b типа аналогичного типу T и совместимого с указателем с a, результатом является указатель на b.
• В противном случае значение указателя не изменяется.

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

• lvalue, если тип-результата является типом 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 также может быть использован для разрешения неоднозначности перегрузки функций, выполняя преобразование функции в указатель на конкретный тип, как в

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();
 
    // 2. lvalue to xvalue
    std::vector<int> v0{1,2,3};
    std::vector<int> v2 = static_cast<std::vector<int>&&>(v0);
    std::cout << "2) after move, v0.size() = " << v0.size() << '\n';
 
    // 3. initializing conversion
    int n = static_cast<int>(3.14);
    std::cout << "3) n = " << n << '\n';
    std::vector<int> v = static_cast<std::vector<int>>(10);
    std::cout << "3) 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 << "5) *ni = " << *ni << '\n';
 
    // 6. array-to-pointer followed by upcast
    D a[10];
    [[maybe_unused]]
    B* dp = static_cast<B*>(a);
 
    // 7. scoped enum to int
    E e = E::TWO;
    int two = static_cast<int>(e);
    std::cout << "7) " << two << '\n';
 
    // 8. int to enum, enum to another enum
    E e2 = static_cast<E>(two);
    [[maybe_unused]]
    EU eu = static_cast<EU>(e2);
 
    // 9. pointer to member upcast
    int D::*pm = &D::m;
    std::cout << "9) " << br.*static_cast<int B::*>(pm) << '\n';
 
    // 10. void* to any type
    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!
2) after move, v0.size() = 0
3) n = 3
3) v.size() = 10
5) *ni = 3
7) 2
9) 42

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

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

См. также

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