Conversión de tipo explícita

Convierte entre tipos utilizando una combinación de conversiones explícitas e implícitas.

[editar] Sintaxis

Devuelve un valor de tipo tipo-de-destino.

[editar] Explicación

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

• Un l-valor si tipo-de-destino es un tipo referencia a l-valor o un tipo referencia r-valor a función (desde C++11);

• Un pr-valor en caso contrario.

[editar] Resolución de ambigüedades

[editar] Instrucción de declaración ambigua

En el caso de una ambigüedad entre una declaración de expresión con una expresión de conversión de estilo función como su subexpresión más a la izquierda y una declaración, la ambigüedad se resuelve tratándola como una declaración. Esta desambiguación es puramente sintáctica: no considera el significado de los nombres que aparecen en la declaración, salvo si son nombres de tipo:

struct M {};
struct L { L(M&); };
 
M n;
void f()
{
    M(m);    // declaración, equivalente a M m;
    L(n);    // declaración mal formada, equivalente a L n;
    L(l)(m); // todavía una declaración, equivalente a L l((m));
}

struct M;
 
struct S
{
    S* operator()();
    int N;
    int M;
 
    void mem(S s)
    {
        auto(s)()->M; // expresión (S::M hides ::M), inválida antes de C++23
    }
};
 
void f(S s)
{
    {
        auto(s)()->N; // expresión, inválida antes de C++23
        auto(s)()->M; // declaración de función, equivalente a M s();
    }
    {
        S(s)()->N;    // expresión
        S(s)()->M;    // expresión
    }
}

[editar] Parámetro de función ambiguo

La ambigüedad anterior también puede ocurrir en el contexto de una declaración. En ese contexto, la elección es entre una declaración de objeto con una función de estilo de conversión como inicializador y una declaración que involucra un declarador de función con un conjunto redundante de paréntesis alrededor de un nombre de parámetro. La solución también es considerar cualquier construcción, como la posible declaración de parámetro, que podría ser una declaración como tal:

struct S
{
    S(int);
};
 
void foo(double a)
{
    S w(int(a)); // declaración de función: tiene un parámetro `a` de tipo int
    S x(int());  // declaración de función: tiene un parámetro sin nombre de tipo int(*)()
                 // que se ajusta desde int()
 
    // Formas de evitar ambigüedad:
    S y((int(a))); // declaración de objeto: extra par de paréntesis
    S y((int)a);   // declaración de objeto: conversión estilo C
    S z = int(a);  // declaración de objeto: no hay ambigüedad para esta sintaxis
}

typedef struct BB { int C[2]; } *B, C;
 
void foo()
{
    S a(B()->C);    // declaración de objeto: B()->C no puede declarar un parámetro
    S b(auto()->C); // declaración de función: tiene un parámetro sin nombre de tipo C(*)()
                    // que está ajustado de C()
}

[editar] id-de-tipo ambiguo

Una ambigüedad puede surgir de la similitud entre una conversión de estilo de función y un id-de-tipo. La solución es que cualquier construcción que podría ser un id-de-tipo en su contexto sintáctico se considerará un id-de-tipo:

// `int()` y `int(unsigned(a))` pueden analizarse como id-de-tipo:
// `int()`            representa una función que devuelve int
//                    y no toma argumentos
// `int(unsigned(a))` representa una función que devuelve int
//                    y toma un argumento de tipo unsigned
void foo(signed char a)
{
    sizeof(int());            // id-de-tipo (mal formado)
    sizeof(int(a));           // expresión
    sizeof(int(unsigned(a))); // id-de-tipo (mal formado)
 
    (int()) + 1;            // id-de-tipo (mal formado)
    (int(a)) + 1;           // expresión
    (int(unsigned(a))) + 1; // id-de-tipo (mal formado)
}

typedef struct BB { int C[2]; } *B, C;
 
void foo()
{
    sizeof(B()->C[1]);    // OK, sizeof(expresión)
    sizeof(auto()->C[1]); // ERROR: sizeof de una función que devuelve un array
}

[editar] Notas

[editar] Ejemplo

#include <cassert>
#include <iostream>
 
double f = 3.14;
unsigned int n1 = (unsigned int)f; // conversión estilo C
unsigned int n2 = unsigned(f);     // conversión estilo función
 
class C1;
class C2;
C2* foo(C1* p)
{
    return (C2*)p; // convierte un tipo incompleto a otro tipo incompleto
}
 
void cpp23_decay_copy_demo()
{
    auto inc_print = [](int& x, const int& y)
    {
        ++x;
        std::cout << "x:" << x << ", y:" << y << '\n';
    };
 
    int p{1};
    inc_print(p, p); // imprime x:2 y:2, porque el parámetro `y` aquí es un alias de `p`
    int q{1};
    inc_print(q, auto{q}); // imprime x:2 y:1, auto{q} (C++23) convierte a pr-valor,
                           // entonces el parámetro `y` es una copia de `q` (no un alias de `q`)
}
 
// En este ejemplo, la conversión estilo C se interpreta como static_cast
// aunque funcionaría como reinterpret_cast
struct A {};
struct I1 : A {};
struct I2 : A {};
struct D : I1, I2 {};
 
int main()
{
    D* d = nullptr;
//  A* a = (A*)d;                   // error en tiempo de compilación
    A* a = reinterpret_cast<A*>(d); // esto compila
    assert(a == nullptr);
 
    cpp23_decay_copy_demo();
}

x:2 y:2
x:2 y:1

[editar] Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

[editar] Referencias

[editar] Véase también