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.