Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::is_convertible — comprobar la conversión implícita

std::is_convertible comprueba en tiempo de compilación si From puede convertirse implícitamente en To. std::is_convertible_v expone el mismo valor bool sin ::value; un resultado positivo no garantiza que se conserve el valor ni que no haya excepciones.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <type_traits>

std::is_convertible<From, To>::value
std::is_convertible_v<From, To>

En la cabecera <type_traits>, el rasgo std::is_convertible<From, To> expone una constante bool mediante ::value. La plantilla de variable std::is_convertible_v<From, To> es una forma abreviada de ese mismo valor. Primero va el tipo de origen y después el tipo de destino.

La prueba modela To test() { return std::declval<From>(); }: comprueba si la conversión implícita es válida sin realizarla. El acceso se comprueba desde un contexto no relacionado con ninguno de los dos tipos; solo se tiene en cuenta el contexto inmediato de la expresión.

Un constructor explicit no basta, aunque std::is_constructible_v<To, From> puede ser true. Las referencias y const importan. Un resultado true no garantiza que no haya pérdida ni excepciones.

Tanto para From como para To se admiten tipos completos, void con o sin calificadores cv y arrays de límite desconocido. No pases una clase incompleta por valor. Cumplir este requisito no basta: si la instanciación depende directa o indirectamente de un tipo de objeto incompleto y completar ese tipo podría cambiar el resultado, el comportamiento es indefinido. Por ejemplo, Derived* y Base* son tipos puntero completos, pero comprobar la conversión de Derived* a Base* da lugar a un comportamiento indefinido si completar la definición de Derived podría cambiar el resultado.

El ejemplo compara constructores implícitos y explicit, y comprueba la vinculación de referencias.

Ejemplos

#include <iostream>
#include <type_traits>

struct Implicit {
    Implicit(int) {}
};

struct Explicit {
    explicit Explicit(int) {}
};

static_assert(std::is_convertible<int, Implicit>::value);
static_assert(!std::is_convertible_v<int, Explicit>);
static_assert(std::is_constructible_v<Explicit, int>);
static_assert(std::is_convertible_v<int&, const int&>);
static_assert(!std::is_convertible_v<const int&, int&>);

int main() {
    std::cout << std::boolalpha
              << std::is_convertible<int, Implicit>::value << '\n'
              << std::is_convertible_v<int, Explicit> << '\n';
}

Resultado

true
false

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes