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

CKTIS / C++

std::convertible_to: conversion implícita y explícita coherentes

std::convertible_to<From, To>, declarado en <concepts>, exige tanto una conversión implícita como una conversión a To mediante static_cast, con resultados coherentes. No basta con que se pueda realizar un cast explícito.

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

Sintaxis

template<class From, class To>
concept convertible_to =
    std::is_convertible_v<From, To> &&
    requires { static_cast<To>(std::declval<From>()); };

std::convertible_to<From, To>, declarado en <concepts>, sirve para restringir plantillas. Su definición combina std::is_convertible_v<From, To> con la validez de static_cast<To>(std::declval<From>()). Tiene en cuenta el tipo y la categoría de valor de std::declval<From>(), por lo que los calificadores y las referencias de From son importantes.

Las conversiones implícita y explícita deben producir resultados iguales cuando To es un tipo objeto o una referencia a un objeto. Se trata de un requisito semántico, no solo de una comprobación sintáctica: que el resultado sea true no demuestra que el compilador haya comprobado el comportamiento de las conversiones definidas por el usuario.

Si std::add_rvalue_reference_t<From> es una referencia a un objeto, las conversiones no deben modificar el objeto de origen, salvo que sea una referencia rvalue a un tipo no const. En esa excepción, el objeto puede quedar en un estado válido pero no especificado. Esta condición no se aplica si el origen no es una referencia a un objeto.

En el ejemplo, short satisface la restricción de as_int. ExplicitOnly permite static_cast<int>, pero su explicit operator int() no proporciona una conversión implícita, así que el concepto es false. El concepto no garantiza una conversión sin pérdida: que ambas formas de conversión coincidan no significa que se conserve todo el valor de origen.

Ejemplos

#include <concepts>
#include <iostream>

struct ExplicitOnly {
    explicit operator int() const { return 7; }
};

template<class T>
    requires std::convertible_to<T, int>
int as_int(T value) {
    return static_cast<T&&>(value);
}

static_assert(std::convertible_to<short, int>);
static_assert(!std::convertible_to<ExplicitOnly, int>);
static_assert(requires(ExplicitOnly x) { static_cast<int>(x); });

int main() {
    std::cout << as_int(short{7}) << '\n';
    std::cout << static_cast<int>(ExplicitOnly{}) << '\n';
}

Resultado

7
7

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