WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

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.

Quellen