CKTIS / C++
std::is_convertible — implizite Konvertierung prüfen
std::is_convertible prüft zur Compilezeit, ob From implizit in To konvertiert werden kann. std::is_convertible_v stellt denselben bool-Wert ohne ::value bereit; ein positives Ergebnis garantiert weder Werterhalt noch Ausnahmefreiheit.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
#include <type_traits>
std::is_convertible<From, To>::value
std::is_convertible_v<From, To>Im Header <type_traits> stellt das Trait std::is_convertible<From, To> über ::value eine bool-Konstante bereit. Das Variablen-Template std::is_convertible_v<From, To> ist eine Kurzform für denselben Wert. Zuerst steht der Quelltyp, danach der Zieltyp.
Der Test bildet To test() { return std::declval<From>(); } nach: Er prüft, ob die implizite Konvertierung gültig ist, ohne sie auszuführen. Der Zugriff wird aus einem Kontext geprüft, der zu keinem der beiden Typen gehört; berücksichtigt wird nur der unmittelbare Kontext des Ausdrucks.
Ein explicit-Konstruktor reicht nicht aus, obwohl std::is_constructible_v<To, From> true sein kann. Referenzen und const sind relevant. Ein Ergebnis von true garantiert weder Verlustfreiheit noch Ausnahmefreiheit.
Für From und To sind jeweils vollständige Typen, void mit oder ohne cv-Qualifizierer oder Arrays unbekannter Größe zulässig. Übergib keine unvollständige Klasse per Wert. Diese Anforderung allein reicht nicht aus: Hängt die Instanziierung direkt oder indirekt von einem unvollständigen Objekttyp ab und könnte dessen Vervollständigung das Ergebnis ändern, ist das Verhalten undefiniert. So sind Derived* und Base* vollständige Zeigertypen; die Prüfung der Konvertierung von Derived* nach Base* hat aber undefiniertes Verhalten, wenn die Vervollständigung von Derived das Ergebnis ändern könnte.
Das Beispiel stellt implizite und explicit-Konstruktoren gegenüber und prüft die Referenzbindung.
Beispiele
#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';
}
Ergebnis
true false
Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.