Was bedeutet das explizite Keyword?

Nehme an, Sie haben eine Klasse String:

class String {
public:
    String(int n); //allocate n bytes to the String object
    String(const char *p); //initializes object with char *p
};

Wenn man jetzt versucht:

String mystring = 'x';

Den Charakter 'x' werden implizit in int und dann die String(int) Konstruktor aufgerufen wird. Aber, das ist nicht das, was der Benutzer haben soll. So, um zu verhindern, dass solche Bedingungen, wir definieren Sie den Konstruktor wie explicit:

class String {
public:
    explicit String (int n); //allocate n bytes
    String(const char *p); //initialize sobject with string p
};

InformationsquelleAutor der Antwort Eddie

Diese Antwort ist über die Objekt-Erstellung mit/ohne expliziten Konstruktor, da es nicht in den anderen Antworten.

Betrachten Sie die folgende Klasse ohne expliziten Konstruktor:

class Foo
{
public:
    Foo(int x) : m_x(x)
    {
    }

private:
    int m_x;
};

Objekte der Klasse Foo erzeugt werden können, 2 Möglichkeiten:

Foo bar1(10);

Foo bar2 = 20;

Je nach Umsetzung, die zweite Art der Instanziierung der Klasse Foo kann verwirrend sein, oder nicht das, was der Programmierer beabsichtigt hat. Indem der explicit Schlüsselwort der Konstruktor erzeugt einen compiler-Fehler, bei Foo bar2 = 20;.

Ist es in der Regel gute Praxis zu erklären, single-argument-Konstruktoren als explicit, es sei denn, Ihre Umsetzung insbesondere verbietet es.

Beachten Sie auch, dass Konstruktoren mit

• Standard-Argumente für alle Parameter, oder
• Standard-Argumente, die für den zweiten parameter ab

genutzt werden können als Einzel-argument Konstruktoren. So möchten Sie vielleicht, um diese auch explicit.

Beispiel, wenn Sie würde absichtlich nicht wollen Ihr single-argument-Konstruktor explicit ist, wenn Sie erstellen einen Funktor (Blick auf die 'add_x' struct deklariert diese Antwort). In einem solchen Fall erstellen Sie ein Objekt als add_x add30 = 30; würde wohl Sinn machen.

Hier ist eine gute schreiben-bis auf explizite Konstruktoren.

InformationsquelleAutor der Antwort Gautam

Das Schlüsselwort explicit begleitet entweder

• ein Konstruktor der Klasse X, die nicht benutzt werden, um implizit konvertiert die erste (und nur) parameter Typ X

C++ [Klasse.conv.ctor]

1) Einen Konstruktor deklariert, ohne das function-specifier explicit gibt eine Umstellung von den Typen Ihrer Parameter, um den Typ seiner Klasse. So wird ein Konstruktor aufgerufen, eine Konvertierung Konstruktor.

2) Eine explizite Konstruktor konstruiert Objekte ebenso wie nicht-explizite Konstruktoren, tut dies aber nur dort, wo die direkte Initialisierung syntax (8.5) oder casts (5.2.9, 5.4) sind explizit verwendet. Ein Standard-Konstruktor kann ein expliziter Konstruktor, so wird ein Konstruktor wird verwendet, um default-Initialisierung oder valueinitialization
(8.5).

• oder eine Konvertierung Funktion, dass gilt nur für die direkte Initialisierung und die explizite Konvertierung.

C++ [Klasse.conv.fct]

2) Eine Umwandlung Funktion kann explizit sein (7.1.2), in welchem Fall es ist nur als einen Benutzer-definierten conversion für direkte Initialisierung (8.5). Ansonsten, benutzerdefinierte Konvertierungen sind nicht beschränkt auf die Nutzung in Aufgaben
und Initialisierungen.

Übersicht

Explizite Konvertierung Funktionen und Konstruktoren können nur verwendet werden, für die Sie explizite Umwandlungen (direkte Initialisierung oder der explizite cast-operation), während nicht-explizite Konstruktoren und Konvertierungsfunktionen können verwendet werden, für die implizite als auch die explizite Konvertierungen.

/*
                                 explicit conversion          implicit conversion

 explicit constructor                    yes                          no

 constructor                             yes                          yes

 explicit conversion function            yes                          no

 conversion function                     yes                          yes

*/

Beispiel mit Strukturen X, Y, Z und Funktionen foo, bar, baz:

Let ' s Blick auf eine kleine setup von Strukturen und Funktionen zu sehen, der Unterschied zwischen explicit - und nicht - explicit Konvertierungen.

struct Z { };

struct X { 
  explicit X(int a); //X can be constructed from int explicitly
  explicit operator Z (); //X can be converted to Z explicitly
};

struct Y{
  Y(int a); //int can be implicitly converted to Y
  operator Z (); //Y can be implicitly converted to Z
};

void foo(X x) { }
void bar(Y y) { }
void baz(Z z) { }

Beispiele über Konstruktor:

Umwandlung einer Funktion argument:

foo(2);                     //error: no implicit conversion int to X possible
foo(X(2));                  //OK: direct initialization: explicit conversion
foo(static_cast<X>(2));     //OK: explicit conversion

bar(2);                     //OK: implicit conversion via Y(int) 
bar(Y(2));                  //OK: direct initialization
bar(static_cast<Y>(2));     //OK: explicit conversion

Objekt-Initialisierung:

X x2 = 2;                   //error: no implicit conversion int to X possible
X x3(2);                    //OK: direct initialization
X x4 = X(2);                //OK: direct initialization
X x5 = static_cast<X>(2);   //OK: explicit conversion 

Y y2 = 2;                   //OK: implicit conversion via Y(int)
Y y3(2);                    //OK: direct initialization
Y y4 = Y(2);                //OK: direct initialization
Y y5 = static_cast<Y>(2);   //OK: explicit conversion

Beispiele bezüglich der Konvertierung Funktionen:

X x1{ 0 };
Y y1{ 0 };

Umwandlung einer Funktion argument:

baz(x1);                    //error: X not implicitly convertible to Z
baz(Z(x1));                 //OK: explicit initialization
baz(static_cast<Z>(x1));    //OK: explicit conversion

baz(y1);                    //OK: implicit conversion via Y::operator Z()
baz(Z(y1));                 //OK: direct initialization
baz(static_cast<Z>(y1));    //OK: explicit conversion

Objekt-Initialisierung:

Z z1 = x1;                  //error: X not implicitly convertible to Z
Z z2(x1);                   //OK: explicit initialization
Z z3 = Z(x1);               //OK: explicit initialization
Z z4 = static_cast<Z>(x1);  //OK: explicit conversion

Z z1 = y1;                  //OK: implicit conversion via Y::operator Z()
Z z2(y1);                   //OK: direct initialization
Z z3 = Z(y1);               //OK: direct initialization
Z z4 = static_cast<Z>(y1);  //OK: explicit conversion

Warum explicit Konvertierungs-Funktionen oder Konstruktoren?

Konvertierungs-Konstruktoren und nicht-explizite Konvertierung-Funktionen möglicherweise nicht mehr eindeutig.

Betrachten eine Struktur V, umbaubar zum int eine Struktur U implizit baubar aus V und eine Funktion f überlastet U und bool bzw.

struct V {
  operator bool() const { return true; }
};

struct U { U(V) { } };

void f(U) { }
void f(bool) {  }

Einen Anruf zu f ist mehrdeutig, wenn Sie ein Objekt vom Typ V.

V x;
f(x);  //error: call of overloaded 'f(V&)' is ambiguous

Der compiler nicht wissen, ob die Verwendung der Konstruktor von U oder die umwandlungsfunktion konvertieren Sie die V Objekt in einen Typ für das bestehen der f.

Wenn entweder der Konstruktor der U oder die Umwandlung von V wäre explicit würde, gäbe es keine Mehrdeutigkeit, da nur die nicht-explizite Konvertierung betrachtet werden würde. Wenn die beiden expliziten Aufruf f mit einem Objekt vom Typ V würde durchgeführt werden müssen, um eine explizite Konvertierung oder cast-operation.

Konvertierungs-Konstruktoren und nicht-explizite Konvertierung-Funktionen kann es zu unerwarteten Ergebnissen kommen.

Betrachten eine Funktion Druck ein Vektor:

void print_intvector(std::vector<int> const &v) { for (int x : v) std::cout << x << '\n'; }

Wenn die Größe-Konstruktor des Vektors würde nicht eindeutig sein, es wäre möglich, rufen Sie die Funktion wie folgt:

print_intvector(3);

Was würde man erwarten von einem solchen Anruf? Eine Zeile, die 3 oder drei Zeilen mit 0? (Wo das zweite ist, was passiert.)

Verwenden des explicit-Schlüsselwort in einer Klasse interface erzwingt die Benutzer der Schnittstelle, die explizit über die gewünschte Konvertierung aus.

Als Bjarne Stroustrup es ausdrückt (in "Die C++ Programmiersprache", 4. Ed., 35.2.1, S. 1011) auf die Frage, warum std::duration nicht implizit konstruiert aus einer einfachen Zahl:

Wenn Sie wissen, was Sie bedeuten, explizit über.

InformationsquelleAutor der Antwort Pixelchemist

Wurde dies bereits diskutiert (was ist explicit-Konstruktor). Aber ich muss sagen, es fehlen die detaillierten Beschreibungen finden Sie hier.

Außerdem ist es immer eine gute Codierung der Praxis, um Ihr ein argument Konstruktoren (einschließlich jene, die mit Standard-Werten für arg2,arg3,...) wie schon gesagt.
Wie immer mit C++: wenn man nicht will, wirst du dir wünschen du hast...

Noch eine gute übung für die Klassen ist, um Kopie-Konstruktion und Zuweisung von privaten (ein.k.ein. deaktivieren Sie es), es sei denn, Sie wirklich brauchen, um es zu implementieren. Dies verhindert, dass allfällige Kopien der Zeiger bei Verwendung der Methoden, die in C++ wird für Sie standardmäßig. Ein anderer Weg, dies zu tun ist eine Ableitung von boost::noncopyable.

InformationsquelleAutor der Antwort fmuecke

Explizite Konvertierungs-Konstruktoren (nur C++)

Die explizite Funktion Bezeichner für Steuerelemente unerwünschte implizite Typ
Konvertierungen. Es kann nur verwendet werden, in der die Deklarationen der Konstruktoren
in der Deklaration einer Klasse. Zum Beispiel, außer für die Standard
Konstruktor die Konstruktoren in der folgenden Klasse sind die Umwandlung
Konstruktoren.

class A
{
public:
    A();
    A(int);
    A(const char*, int = 0);
};

Den folgenden Deklarationen sind zulässig:

A c = 1;
A d = "Venditti";

Die erste Deklaration ist äquivalent zu A c = A( 1 );.

Wenn Sie deklarieren, wird der Konstruktor der Klasse als explicit die früheren Erklärungen wäre illegal.

Zum Beispiel, wenn Sie die Klasse deklarieren:

class A
{
public:
    explicit A();
    explicit A(int);
    explicit A(const char*, int = 0);
};

Können Sie nur Werte zuweisen, die den Werten entsprechen, die von der Klasse geben.

Beispielsweise die folgenden Anweisungen sind zulässig:

  A a1;
  A a2 = A(1);
  A a3(1);
  A a4 = A("Venditti");
  A* p = new A(1);
  A a5 = (A)1;
  A a6 = static_cast<A>(1);

InformationsquelleAutor der Antwort coding_ninza