Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::is_convertible — testar a conversão implícita

std::is_convertible verifica em tempo de compilação se From pode ser convertido implicitamente em To. std::is_convertible_v disponibiliza o mesmo valor bool sem ::value; um resultado positivo não garante a preservação do valor nem a ausência de exceções.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <type_traits>

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

No cabeçalho <type_traits>, o trait std::is_convertible<From, To> disponibiliza uma constante bool através de ::value. O modelo de variável std::is_convertible_v<From, To> é uma forma abreviada do mesmo valor. Primeiro surge o tipo de origem, seguido do tipo de destino.

O teste modela To test() { return std::declval<From>(); }: verifica se a conversão implícita é válida sem a executar. O acesso é verificado a partir de um contexto sem relação com nenhum dos tipos; só é considerado o contexto imediato da expressão.

Um construtor explicit não é suficiente, embora std::is_constructible_v<To, From> possa ser true. As referências e const são relevantes. Um resultado true não garante ausência de perdas nem de exceções.

Tanto para From como para To, são permitidos tipos completos, void com ou sem qualificadores cv e arrays de limite desconhecido. Não passe uma classe incompleta por valor. Cumprir este requisito não basta: se a instanciação depender direta ou indiretamente de um tipo de objeto incompleto e completar esse tipo puder alterar o resultado, o comportamento é indefinido. Por exemplo, Derived* e Base* são tipos ponteiro completos, mas testar a conversão de Derived* para Base* tem comportamento indefinido se completar a definição de Derived puder alterar o resultado.

O exemplo compara construtores implícitos e explicit e verifica a ligação de referências.

Exemplos

#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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes