c++ schlüsselwörter bedeutung - Was bedeutet das explizite Keyword?





5 Answers

Angenommen, 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
};

Nun, wenn Sie versuchen:

String mystring = 'x';

Das Zeichen 'x' wird implizit in int konvertiert und der String(int) -Konstruktor wird aufgerufen. Dies ist jedoch nicht das, was der Benutzer beabsichtigt hat. Um solche Bedingungen zu vermeiden, definieren wir den Konstruktor als explicit :

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

Was bedeutet das explicit Schlüsselwort in C ++?




Bei dieser Antwort geht es um die Objekterstellung mit / ohne expliziten Konstruktor, da sie in den anderen Antworten nicht behandelt wird.

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 können auf zwei Arten erstellt werden:

Foo bar1(10);

Foo bar2 = 20;

Je nach Implementierung kann die zweite Art der Instanziierung der Klasse Foo verwirrend sein oder nicht, was der Programmierer beabsichtigt hat. Wenn Sie das explicit Schlüsselwort dem Konstruktor Foo bar2 = 20; wird bei Foo bar2 = 20; ein Compilerfehler generiert Foo bar2 = 20; .

Normalerweise empfiehlt es sich, Konstruktoren mit einem Argument als explicit zu deklarieren, es sei denn, Ihre Implementierung verbietet dies explicit .

Beachten Sie auch, dass Konstruktoren mit

  • Standardargumente für alle Parameter oder
  • Standardargumente ab dem zweiten Parameter

können beide als Konstrukteure mit einem Argument verwendet werden. Daher möchten Sie diese auch explicit .

Ein Beispiel, in dem Sie Ihren Konstruktor mit einem einzigen Argument absichtlich nicht explizit machen möchten, ist das Erstellen eines Funktors (siehe die in this Antwort deklarierte Struktur 'add_x'). In einem solchen Fall erstellen Sie ein Objekt als add_x add30 = 30; wäre wahrscheinlich sinnvoll.

Here ist ein guter Bericht über explizite Konstruktoren.




Das explicit Schlüsselwort wird entweder mitgeliefert

  • ein Konstruktor der Klasse X, der nicht verwendet werden kann, um den ersten (nur beliebigen) Parameter implizit in den Typ X zu konvertieren

C ++ [class.conv.ctor]

1) Ein Konstruktor, der ohne den expliziten Funktionsspezifizierer deklariert wurde, gibt eine Konvertierung von den Typen seiner Parameter in den Typ seiner Klasse an. Ein solcher Konstruktor wird Konvertierungskonstruktor genannt.

2) Ein expliziter Konstruktor erstellt Objekte genauso wie nicht explizite Konstruktoren, dies jedoch nur, wenn die Direktinitialisierungssyntax (8.5) oder die Umwandlung (5.2.9, 5.4) explizit verwendet wird. Ein Standardkonstruktor kann ein expliziter Konstruktor sein. Ein solcher Konstruktor wird zur Ausführung der Standardinitialisierung oder Wertinitialisierung (8.5) verwendet.

  • oder eine Konvertierungsfunktion, die nur für die direkte Initialisierung und explizite Konvertierung berücksichtigt wird.

C ++ [class.conv.fct]

2) Eine Konvertierungsfunktion kann explizit sein (7.1.2). In diesem Fall wird sie nur als benutzerdefinierte Konvertierung für die Direktinitialisierung (8.5) betrachtet. Andernfalls sind benutzerdefinierte Konvertierungen nicht auf Zuweisungen und Initialisierungen beschränkt.

Überblick

Explizite Konvertierungsfunktionen und Konstruktoren können nur für explizite Konvertierungen (direkte Initialisierung oder explizite Umwandlungsoperation) verwendet werden, nicht explizite Konstruktoren und Konvertierungsfunktionen können für implizite und explizite Konvertierungen verwendet werden.

/*
                                 explicit conversion          implicit conversion

 explicit constructor                    yes                          no

 constructor                             yes                          yes

 explicit conversion function            yes                          no

 conversion function                     yes                          yes

*/

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

Lassen Sie uns einen kleinen Aufbau von Strukturen und Funktionen betrachten, um den Unterschied zwischen explicit und nicht explicit Konvertierungen zu erkennen.

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 zum Konstruktor:

Konvertierung eines Funktionsarguments:

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

Objektinitialisierung:

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 zu Konvertierungsfunktionen:

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

Konvertierung eines Funktionsarguments:

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

Objektinitialisierung:

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 Konvertierungsfunktionen oder Konstruktoren verwenden?

Konvertierungskonstruktoren und nicht explizite Konvertierungsfunktionen können Mehrdeutigkeiten verursachen.

Man betrachte eine Struktur V , konvertierbar in int , eine aus U implizit konstruierbare Struktur U und eine für U und bool überladene Funktion f .

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

struct U { U(V) { } };

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

Ein Aufruf an f ist mehrdeutig, wenn ein Objekt vom Typ V .

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

Der Compiler weiß nicht, ob er den Konstruktor von U oder die Konvertierungsfunktion verwenden soll, um das V Objekt in einen Typ zu konvertieren, der an f .

Wenn entweder der Konstruktor von U oder die Konvertierungsfunktion von V explicit , würde es keine Mehrdeutigkeit geben, da nur die nicht explizite Konvertierung berücksichtigt würde. Wenn beide explizit sind, müsste der Aufruf von f mit einem Objekt vom Typ V mit einer expliziten Konvertierungs- oder Umwandlungsoperation erfolgen.

Konvertierungskonstruktoren und nicht explizite Konvertierungsfunktionen können zu unerwartetem Verhalten führen.

Betrachten Sie eine Funktion, die einen Vektor druckt:

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

Wenn der Größenkonstruktor des Vektors nicht explizit wäre, könnte die Funktion folgendermaßen aufgerufen werden:

print_intvector(3);

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

Die Verwendung des expliziten Schlüsselworts in einer Klassenschnittstelle erzwingt, dass der Benutzer der Schnittstelle explizit über eine gewünschte Konvertierung handelt.

Wie Bjarne Stroustrup (in "Die Programmiersprache C ++", 4. Aufl., 35.2.1, S. 1011) über die Frage formuliert, warum std::duration nicht implizit aus einer einfachen Zahl konstruiert werden kann:

Wenn Sie wissen, was Sie meinen, machen Sie das explizit.




Dies wurde bereits diskutiert ( was ist der explizite Konstruktor ). Aber ich muss sagen, dass es die detaillierten Beschreibungen hier fehlt.

Außerdem ist es immer eine gute Kodierungspraxis, wie Sie bereits einen Argumentkonstruktor (einschließlich solcher mit Standardwerten für arg2, arg3, ...) erstellt haben. Wie immer bei C ++: Wenn Sie dies nicht tun, wünschen Sie das auch ...

Eine weitere bewährte Methode für Klassen besteht darin, die Erstellung und Zuweisung von Kopien als privat zu definieren (dh deaktivieren Sie sie), sofern Sie sie nicht wirklich implementieren müssen. Dadurch wird vermieden, dass bei Verwendung der Methoden, die C ++ standardmäßig für Sie erstellt, möglicherweise Zeigerkopien verwendet werden. Ein anderer Weg, dies zu tun, ist von boost :: noncopyable.




Explizite Konvertierungskonstruktoren (nur C ++)

Der explizite Funktionsbezeichner steuert unerwünschte implizite Typkonvertierungen. Es kann nur in Deklarationen von Konstruktoren innerhalb einer Klassendeklaration verwendet werden. Mit Ausnahme des Standardkonstruktors sind die Konstruktoren in der folgenden Klasse beispielsweise Konvertierungskonstruktoren.

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

Die folgenden Erklärungen sind legal:

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

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

Wenn Sie den Konstruktor der Klasse als explicit deklarieren, wären die vorherigen Deklarationen ungültig.

Wenn Sie beispielsweise die Klasse als deklarieren:

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

Sie können nur Werte zuweisen, die den Werten des Klassentyps entsprechen.

Zum Beispiel sind die folgenden Aussagen 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);



Related