Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::is_convertible — verificare la conversione implicita

std::is_convertible verifica in fase di compilazione se From può essere convertito implicitamente in To. std::is_convertible_v espone lo stesso valore bool senza ::value; un risultato positivo non garantisce la conservazione del valore né l’assenza di eccezioni.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <type_traits>

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

Nell’header <type_traits>, il tratto std::is_convertible<From, To> espone una costante bool tramite ::value. Il modello di variabile std::is_convertible_v<From, To> è una forma abbreviata dello stesso valore. Prima viene il tipo sorgente, seguito dal tipo destinazione.

Il test modella To test() { return std::declval<From>(); }: verifica che la conversione implicita sia valida senza eseguirla. L’accesso viene verificato da un contesto non correlato a nessuno dei due tipi; si considera solo il contesto immediato dell’espressione.

Un costruttore explicit non è sufficiente, anche se std::is_constructible_v<To, From> può essere true. Riferimenti e const sono rilevanti. Un risultato true non garantisce né l’assenza di perdita né quella di eccezioni.

Sia per From sia per To sono ammessi tipi completi, void con o senza qualificatori cv e array di dimensione sconosciuta. Non passare una classe incompleta per valore. Soddisfare questo requisito non basta: se l’istanziazione dipende direttamente o indirettamente da un tipo di oggetto incompleto e completare quel tipo potrebbe cambiare il risultato, il comportamento è indefinito. Per esempio, Derived* e Base* sono tipi puntatore completi, ma verificare la conversione da Derived* a Base* comporta un comportamento indefinito se completare la definizione di Derived potrebbe cambiare il risultato.

L’esempio confronta costruttori impliciti ed explicit e verifica il binding dei riferimenti.

Esempi

#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';
}

Risultato

true
false

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti