CKTIS / C++
std::convertible_to — overeenstemmende impliciete en expliciete conversie
std::convertible_to<From, To> uit <concepts> vereist zowel impliciete conversie als conversie naar To via static_cast, met overeenstemmende resultaten. Alleen een expliciete cast kunnen uitvoeren is niet voldoende.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
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> uit <concepts> wordt gebruikt om templates te begrenzen. De definitie combineert std::is_convertible_v<From, To> met de geldigheid van static_cast<To>(std::declval<From>()). Het type en de waardecategorie van std::declval<From>() tellen mee; kwalificaties en referenties in From zijn dus van belang.
De impliciete en expliciete conversies moeten gelijke resultaten opleveren wanneer To een objecttype of een referentie naar een object is. Dit is een semantische eis en niet slechts een syntaxiscontrole: een resultaat true bewijst niet dat de compiler het gedrag van door de gebruiker gedefinieerde conversies heeft gecontroleerd.
Als std::add_rvalue_reference_t<From> een referentie naar een object is, mogen de conversies het bronobject niet wijzigen, tenzij het een rvalue-referentie naar een niet-const-type is. In die uitzondering mag het object achterblijven in een geldige maar niet-gespecificeerde toestand. Deze voorwaarde geldt niet wanneer de bron geen referentie naar een object is.
In het voorbeeld voldoet short aan de beperking van as_int. ExplicitOnly ondersteunt static_cast<int>, maar zijn explicit operator int() biedt geen impliciete conversie; daarom is het concept false. Het concept garandeert geen verliesvrije conversie: overeenstemming tussen de twee conversievormen betekent niet dat de volledige bronwaarde behouden blijft.
Voorbeelden
#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';
}
Resultaat
7 7
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.