CKTIS / C++
std::convertible_to — conversions implicite et explicite cohérentes
std::convertible_to<From, To>, déclaré dans <concepts>, exige à la fois une conversion implicite et une conversion vers To par static_cast, avec des résultats cohérents. La seule possibilité d’effectuer un cast explicite ne suffit pas.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
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>, déclaré dans <concepts>, permet de contraindre les modèles. Sa définition combine std::is_convertible_v<From, To> et la validité de static_cast<To>(std::declval<From>()). Le type et la catégorie de valeur de std::declval<From>() sont pris en compte : les qualificatifs et les références de From ont donc leur importance.
Les conversions implicite et explicite doivent produire des résultats égaux lorsque To est un type objet ou une référence vers un objet. Il s’agit d’une exigence sémantique, et non d’un simple contrôle de syntaxe : un résultat true ne prouve pas que le compilateur a vérifié le comportement des conversions définies par l’utilisateur.
Si std::add_rvalue_reference_t<From> est une référence vers un objet, les conversions ne doivent pas modifier l’objet source, sauf s’il s’agit d’une référence rvalue vers un type non-const. Dans ce cas particulier, l’objet peut rester dans un état valide mais non spécifié. Cette condition ne s’applique pas lorsque la source n’est pas une référence vers un objet.
Dans l’exemple, short satisfait la contrainte de as_int. ExplicitOnly autorise static_cast<int>, mais son explicit operator int() ne fournit pas de conversion implicite ; le concept vaut donc false. Le concept ne garantit pas une conversion sans perte : l’accord entre les deux formes de conversion ne signifie pas que toute la valeur source est préservée.
Exemples
#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';
}
Résultat
7 7
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.