WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

explicit — implizite Konvertierungen steuern

Der Specifier explicit schränkt ein, wann Konstruktoren und Konvertierungsfunktionen für implizite Konvertierungen verwendet werden, lässt aber eine bewusste Objekterzeugung zu. Lerne den Unterschied zwischen direkter und kopierender Initialisierung, die besondere Rolle von operator bool und explicit(condition) kennen.

Version: C++23; repository compiler flag, production runtime not attested

Syntax

explicit ClassName(parameters);
explicit operator TargetType() const;
explicit(condition) ClassName(parameters);
explicit(condition) operator TargetType() const;

explicit hilft dabei, unbeabsichtigte benutzerdefinierte Konvertierungen einzuschränken. Es kann einen Konstruktor oder eine Konvertierungsfunktion innerhalb einer Klassendefinition kennzeichnen; für gewöhnliche Funktionen ist es kein Specifier. Es kann auch bei Deduktionsleitern für Klassenvorlagen auftreten. Ein einfaches explicit bedeutet explicit(true).

Bei einem Konstruktor explicit Count(int) sind sowohl Count a(3); als auch Count b{3}; gültige direkte Initialisierungen. Count c = 3; ist ungültig, weil die kopierende Initialisierung diesen Konstruktor nicht zur Konvertierung verwendet. Count d = {3}; ist ebenfalls ungültig, wenn die kopierende Listeninitialisierung einen explicit-Konstruktor auswählt. Ebenso kann eine Funktion, die Count entgegennimmt, nicht einfach 3 akzeptieren, aber sie kann Count{3} erhalten. Der Specifier ist nicht auf Konstruktoren mit einem Parameter beschränkt.

Eine Konvertierungsfunktion explicit operator bool() const verhindert bool e = a;, erlaubt aber static_cast<bool>(a) und die direkte Initialisierung bool e(a);. Boolesche Bedingungen sind eine wichtige Ausnahme: if (a) kann diesen Operator verwenden, weil die kontextuelle Konvertierung zu bool prüft, ob eine direkte Initialisierung möglich ist. Dadurch werden implizite Konvertierungen nicht allgemein zugelassen.

In C++23 gelten für explicit(condition) strengere Regeln als für eine gewöhnliche if-Bedingung: Das Ergebnis der kontextuellen Konvertierung zu bool muss ein konstanter Ausdruck sein, und die Konvertierungssequenz darf nur zulässige Konvertierungen enthalten, keine einengenden. Beispielsweise ist 2 ein konstanter Ausdruck und als Bedingung in if (2) zulässig. explicit(2) ist dagegen ungültig, weil die Konvertierung von 2 zu bool einengend ist. Der Wert true aktiviert explicit; bei false ist die Deklaration nicht explizit. Das ist kein Laufzeitschalter. Es ist in Vorlagen nützlich, wenn die implizite Konvertierbarkeit vom Typ abhängt. Das Beispiel verwendet den C++23-Modus. Die Quellen zeigen einen sich weiterentwickelnden Arbeitsentwurf, keine eingefrorene C++23-Veröffentlichung.

Beispiele

#include <iostream>
#include <type_traits>

struct Count {
    int value;
    explicit Count(int n) : value(n) {}
    explicit operator bool() const { return value != 0; }
};

static_assert(std::is_constructible_v<Count, int>);
static_assert(!std::is_convertible_v<int, Count>);
static_assert(!std::is_convertible_v<Count, bool>);

int main() {
    Count a(3);
    Count b{0};
    // Count c = 3;
    // Count d = {3};
    // bool e = a;
    if (a) {
        std::cout << a.value << '\n';
    }
    std::cout << std::boolalpha << static_cast<bool>(b) << '\n';
}

Ergebnis

3
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