Was bedeutet das Schlüsselwort explicit?

Question

Was bedeutet die explicit Schlüsselwort in C++ bedeuten?

Answer 1

El explicit Schlüsselwort macht aus einem Konvertierungskonstruktor einen Nicht-Konvertierungskonstruktor. Infolgedessen ist der Code weniger fehleranfällig.

Answer 2

El explicit -Schlüsselwort kann verwendet werden, um den Aufruf eines Konstruktors zu erzwingen ausdrücklich .

class C {
public:
    explicit C() =default;
};

int main() {
    C c;
    return 0;
}

el explicit -Schlüsselwort vor dem Konstruktor C() teilt dem Compiler mit, dass nur explizite Aufrufe dieses Konstruktors erlaubt sind.

El explicit -Schlüsselwort kann auch in benutzerdefinierten Typ-Cast-Operatoren verwendet werden:

class C{
public:
    explicit inline operator bool() const {
        return true;
    }
};

int main() {
    C c;
    bool b = static_cast<bool>(c);
    return 0;
}

Hier, explicit -Schlüsselwort erzwingt, dass nur explizite Würfe gültig sind, also bool b = c; wäre in diesem Fall ein ungültiger Wurf. In Situationen wie diesen explicit -Schlüsselwort kann dem Programmierer helfen, implizite, unbeabsichtigte Würfe zu vermeiden. Diese Verwendung ist standardisiert worden in C++11 .

Answer 3

Cpp Referenz ist immer hilfreich!!! Details zum expliziten Spezifizierer finden Sie unter aquí . Möglicherweise müssen Sie sich Folgendes ansehen implizite Konvertierungen y Kopier-Initialisierung auch.

Schneller Blick

Der explizite Spezifizierer gibt an, dass ein Konstruktor oder eine Konvertierungsfunktion (seit C++11) keine impliziten Konvertierungen oder Kopierinitialisierungen zulässt.

Beispiel wie folgt:

struct A
{
    A(int) { }      // converting constructor
    A(int, int) { } // converting constructor (C++11)
    operator bool() const { return true; }
};

struct B
{
    explicit B(int) { }
    explicit B(int, int) { }
    explicit operator bool() const { return true; }
};

int main()
{
    A a1 = 1;      // OK: copy-initialization selects A::A(int)
    A a2(2);       // OK: direct-initialization selects A::A(int)
    A a3 {4, 5};   // OK: direct-list-initialization selects A::A(int, int)
    A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
    A a5 = (A)1;   // OK: explicit cast performs static_cast
    if (a1) cout << "true" << endl; // OK: A::operator bool()
    bool na1 = a1; // OK: copy-initialization selects A::operator bool()
    bool na2 = static_cast<bool>(a1); // OK: static_cast performs direct-initialization

//  B b1 = 1;      // error: copy-initialization does not consider B::B(int)
    B b2(2);       // OK: direct-initialization selects B::B(int)
    B b3 {4, 5};   // OK: direct-list-initialization selects B::B(int, int)
//  B b4 = {4, 5}; // error: copy-list-initialization does not consider B::B(int,int)
    B b5 = (B)1;   // OK: explicit cast performs static_cast
    if (b5) cout << "true" << endl; // OK: B::operator bool()
//  bool nb1 = b2; // error: copy-initialization does not consider B::operator bool()
    bool nb2 = static_cast<bool>(b2); // OK: static_cast performs direct-initialization
}

Answer 4

Es ist immer eine gute Programmierpraxis, Ihre Ein-Argument-Konstruktoren (einschließlich derjenigen mit Standardwerten für arg2 , arg3 ,...) wie bereits erwähnt. Wie immer bei C++: Wenn Sie es nicht tun, werden Sie sich wünschen, Sie hätten es getan...

Eine weitere gute Praxis für Klassen ist es, die Konstruktion und Zuweisung von Kopien privat zu machen (d.h. zu deaktivieren), es sei denn, Sie müssen sie wirklich implementieren. Dadurch wird vermieden, dass bei der Verwendung der Methoden, die C++ standardmäßig für Sie erstellt, eventuelle Kopien von Zeigern entstehen. Eine andere Möglichkeit, dies zu tun, ist die Ableitung von boost::noncopyable .

Answer 5

Die Konstrukteure fügen eine implizite Konvertierung hinzu. Um diese implizite Umwandlung zu unterdrücken, ist es erforderlich, einen Konstruktor mit einem expliziten Parameter zu deklarieren.

In C++11 können Sie auch einen "Operatortyp()" mit einem solchen Schlüsselwort angeben http://en.cppreference.com/w/cpp/language/explicit Mit einer solchen Spezifikation können Sie Operator in Form von expliziten Konvertierungen und direkter Initialisierung von Objekten verwenden.

P.S. Bei der Verwendung von Transformationen, die BY USER (über Konstruktoren und Typkonvertierungsoperatoren) definiert wurden, darf nur eine Ebene von impliziten Konvertierungen verwendet werden. Aber Sie können diese Konvertierungen mit anderen Sprachkonvertierungen kombinieren

• ganzzahlige Ränge aufwärts (char zu int, float zu double);
• Standardkonvertierungen (int nach double);
• Zeiger von Objekten in die Basisklasse und in void* umwandeln;