CKTIS / C++
std::convertible_to — conversioni implicita ed esplicita coerenti
std::convertible_to<From, To>, dichiarato in <concepts>, richiede sia una conversione implicita sia una conversione a To tramite static_cast, con risultati coerenti. La sola possibilità di eseguire un cast esplicito non è sufficiente.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
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>, dichiarato in <concepts>, consente di imporre vincoli ai template. La sua definizione combina std::is_convertible_v<From, To> con la validità di static_cast<To>(std::declval<From>()). Tiene conto del tipo e della categoria di valore di std::declval<From>(), quindi qualificatori e riferimenti in From sono importanti.
Le conversioni implicita ed esplicita devono produrre risultati uguali quando To è un tipo oggetto o un riferimento a un oggetto. È un requisito semantico, non un semplice controllo sintattico: un risultato true non dimostra che il compilatore abbia verificato il comportamento delle conversioni definite dall’utente.
Se std::add_rvalue_reference_t<From> è un riferimento a un oggetto, le conversioni non devono modificare l’oggetto sorgente, a meno che non si tratti di un riferimento rvalue a un tipo non-const. In questa eccezione, l’oggetto può restare in uno stato valido ma non specificato. Questa condizione non si applica quando la sorgente non è un riferimento a un oggetto.
Nell’esempio, short soddisfa il vincolo di as_int. ExplicitOnly consente static_cast<int>, ma il suo explicit operator int() non offre una conversione implicita, quindi il concept è false. Il concept non garantisce una conversione senza perdita: la corrispondenza tra le due forme di conversione non significa che l’intero valore sorgente venga preservato.
Esempi
#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';
}
Risultato
7 7
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.