static_cast conversion

Convierte entre tipos usando una combinación de conversiones implícitas y definidas por el usuario.

Sintaxis

Devuelve un valor de tipo target-type .

Explicación

Solo las siguientes conversiones pueden realizarse con static_cast , excepto cuando dichas conversiones eliminen la constancia (o volatilidad).

struct B {};
struct D : B { B b; };
D d;
B& br1 = d;
B& br2 = d.b;
static_cast<D&>(br1); // OK, lvalue que denota el objeto original "d"
static_cast<D&>(br2); // UB: el subobjeto "b" no es un subobjeto de clase base

Como con todas las expresiones de conversión, el resultado es:

• un lvalue si target-type es un tipo de referencia lvalue o una referencia rvalue a tipo función (desde C++11) ;

• un prvalue en caso contrario.

1. ↑ Este tipo de static_cast se utiliza para implementar la semántica de movimiento en std::move .
2. ↑ Si la aritmética IEEE está soportada, el redondeo por defecto es al más cercano.

Objetos intercambiables por puntero

Dos objetos a y b son pointer-interconvertible si:

• son el mismo objeto, o
• uno es un objeto union y el otro es un miembro de datos no estático de ese objeto, o
• uno es un objeto de clase standard-layout y el otro es el primer miembro de datos no estático de ese objeto o cualquier subobjeto de clase base de ese objeto, o
• existe un objeto c tal que a y c son pointer-interconvertible, y c y b son pointer-interconvertible.

union U { int a; double b; } u;
void* x = &u;                        // el valor de x es "puntero a u"
double* y = static_cast<double*>(x); // el valor de y es "puntero a u.b"
char* z = static_cast<char*>(x);     // el valor de z es "puntero a u"

Notas

Conversiones de base a derivado ( downcasts ) usando static_cast no realizan comprobaciones en tiempo de ejecución para garantizar que el tipo dinámico del objeto apuntado/referenciado es Derived , y solo pueden usarse de forma segura si esta precondición está garantizada por otros medios, como al implementar polimorfismo estático . El downcast seguro puede realizarse con dynamic_cast .

static_cast también puede utilizarse para eliminar la ambigüedad de sobrecargas de funciones realizando una conversión de función a puntero a un tipo específico, como en

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

Palabras clave

static_cast

Ejemplo

#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. conversión descendente estática
    D d;
    B& br = d; // conversión ascendente mediante conversión implícita
    std::cout << "1) " << br.hello();
    D& another_d = static_cast<D&>(br); // conversión descendente
    std::cout << "1) " << another_d.hello();
    // 3. lvalue a xvalue
    std::vector<int> v0{1, 2, 3};
    std::vector<int> v2 = static_cast<std::vector<int>&&>(v0);
    std::cout << "3) después del movimiento, v0.size() = " << v0.size() << '\n';
    // 4. expresión de valor descartado
    static_cast<void>(v2.size());
    // 5. conversión de inicialización
    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. inverso de conversión implícita
    void* nv = &n;
    int* ni = static_cast<int*>(nv);
    std::cout << "6) *ni = " << *ni << '\n';
    // 7a. enumeración con ámbito a int
    E e = E::TWO;
    int two = static_cast<int>(e);
    std::cout << "7a) " << two << '\n';
    // 7b. int a enumeración, enumeración a otra enumeración
    E e2 = static_cast<E>(two);
    [[maybe_unused]]
    EU eu = static_cast<EU>(e2);
    // 7f. puntero a miembro conversión ascendente
    int D::*pm = &D::m;
    std::cout << "7f) " << br.*static_cast<int B::*>(pm) << '\n';
    // 7g. void* a cualquier puntero de objeto
    void* voidp = &e;
    [[maybe_unused]]
    std::vector<int>* p = static_cast<std::vector<int>*>(voidp);
}

1) Hola mundo, ¡este es B!
1) Hola mundo, ¡este es D!
3) después de mover, v0.size() = 0
5) n = 3
5) v.size() = 10
6) *ni = 3
7a) 2
7f) 42

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

Referencias

Véase también

• const_cast
• dynamic_cast
• reinterpret_cast
• conversión explícita
• conversiones implícitas