Explicit type conversion

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

Sintaxis

Convierte explícitamente cualquier cantidad de valores a un valor del tipo de destino.

Explicación

Resolución de Ambigüedad

Declaración ambigua

En caso de ambigüedad entre una sentencia 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 sentencia de 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 sentencia, excepto 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 incorrecta, equivalente a L n;
    L(l)(m); // sigue siendo 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 oculta ::M), inválido antes de C++23
    }
};
void f(S s)
{
    {
        auto(s)()->N; // expresión, inválido 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
    }
}

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 está entre una declaración de objeto con un cast de estilo funció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 resolución también es considerar cualquier construcción, como la posible declaración de parámetro, que posiblemente podría ser una declaración como una declaración:

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: paréntesis adicional
    S y((int)a);   // declaración de objeto: conversión estilo C
    S z = int(a);  // declaración de objeto: no hay ambigüedad con 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 se ajusta desde C()
}

Identificador de tipo ambiguo

Una ambigüedad puede surgir de la similitud entre un cast de estilo función y un type-id . La resolución es que cualquier construcción que posiblemente pueda ser un type-id en su contexto sintáctico será considerada un type-id:

// `int()` y `int(unsigned(a))` pueden ser analizados como type-id:
// `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());            // type-id (mal formado)
    sizeof(int(a));           // expresión
    sizeof(int(unsigned(a))); // type-id (mal formado)
    (int()) + 1;            // type-id (mal formado)
    (int(a)) + 1;           // expresión
    (int(unsigned(a))) + 1; // type-id (mal formado)
}

typedef struct BB { int C[2]; } *B, C;
void foo()
{
    sizeof(B()->C[1]);    // OK, sizeof(expression)
    sizeof(auto()->C[1]); // error: sizeof of a function returning an array
}

Notas

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 tipo incompleto a 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 prvalue,
                           // por lo que 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

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