Expliziter Aufruf eines Konstruktors

Gibt es zwei verschiedene Probleme hier, wie Ihre definition von explizite und implizite nicht mit der standard-definition - (auf denen die meisten der bisherigen Antworten basieren, geschrieben werden, bevor Sie Hinzugefügt, dein Beispiel mit Ihrer eigenen definition von explizite und implizite).

Ok, so betrachten Sie zunächst Ihre definition von explizite, das wäre (ich denke, Sie nennen es explizite, da Sie ausdrücklich schreiben, der Typ-name?):

integer int1 = integer(0, 100);

gegen Ihre definition von implizite wäre:

integer int1(1, 100);

In diesem Fall die erste "explicit" nennen, wirklich keinen Vorteil gegenüber dem zweiten "implizite" nennen. Aber es gibt noch einen Unterschied. Die erste, tatsächlich erstellt eine temporäre Verwendung der zwei-argument-Konstruktor, der dann verwendet wird, zu erstellen int1 mit Hilfe der copy-Konstruktor. Obwohl in der Praxis der compiler wird in der Regel optimieren diese zusätzliche Kopie, die es immer noch nicht funktionieren, wenn Sie Ihre Kopie-Konstruktor privat ist, in der Erwägung, dass die zweite braucht man nur die zwei-argument-Konstruktor (konnte man sogar sehen dies als Nachteil).

Nun aber zu der eigentlichen standard-Definitionen von explizite und implizite. Ein explizite Konstruktor-Aufruf ist jeder Konstruktor-Aufruf werden Sie, gut, explizit zu nennen. Praktisch gesprochen, immer dann, wenn Sie die Klammer-syntax () um ein Objekt zu erstellen, die Sie der explizite Aufruf eines Konstruktors, ansonsten ist es ein implizite Konstruktor-Aufruf (so zu sagen, wird getan hinter den kulissen durch den compiler):

integer int1;                   //implicit default constructor
integer int1(1, 100);           //explicit two-arg constructor
integer int1 = integer(0, 100); //explicit two-arg constructor, implicit copy constructor

void func(integer);             //function taking by-value
func(int1);                     //implicit copy constructor

Also nur die Konstruktoren aufgerufen werden kann implizit sind die Standard-construtor und alle ein-argument-Konstruktoren (einschließlich kopieren und verschieben von Konstruktoren). Ein besonderes problem in diesem Zusammenhang sind ein-argument-Konstruktoren nicht kopieren/verschieben Konstruktoren:

struct integer
{
    integer(int);
};

Dieser kann der compiler imlicitly rufen Sie den Konstruktor zum konvertieren von Typen, damit jeder int implizit konvertierbar integer:

void func(integer);
func(42);             //implicit call to int-constructor

Verbieten, ein solches Verhalten würden Sie haben, um die Konstruktor explicit:

struct integer
{
    explicit integer(int);
};

Die nur erlaubt es, genannt zu werden explizit (z.B. func(integer(42))) (aber ich denke, Sie wussten schon). Dies hat den Vorteil, dass es nicht vorstellen unbemerkten/ungewollten Konvertierungen hinter den kulissen, die kann dazu führen, alle Arten von schwer zu finden, Probleme und Unklarheiten in Bezug auf überlast-Auflösung. Es ist daher üblich, das mark keine Konvertierung Konstruktoren (ein-argument-nicht-kopieren/verschieben Konstruktoren) explicit, und die meisten wahrscheinlich auch der Grund, warum C++11 endlich eingeführt explicit konvertierungsoperatoren.

Also zu summieren, entsprechend Ihrer definition und Beispiel, gibt es wirklich keinen Vorteil bei der Verwendung von integer int1 = integer(1, 100); statt integer int1(1, 100);, aber es macht einen (in der Regel irrelevant) Unterschied.

Aber nach den standard-Definitionen, explizite Konstruktor-Aufrufe haben viele Vorteile gegenüber implizite, da der einzige Weg, um tatsächlich bauen gemeinsam ein Objekt explizit ist zu verwenden, na expliziten Konstruktor-Aufruf, in der Erwägung, dass implizite Konstruktor-Aufrufe sind nur hinter den kulissen in bestimmten Situationen und nur Arbeit für den null - und ein-argument-Konstruktoren (wie aschepler bereits darauf hingewiesen). Und explizit Kennzeichnung Konvertierungs-Konstruktoren als explicit hat den Vorteil, verhindert unerwünschte implizite Konvertierungen hinter die kulissen.

Gibt es drei Möglichkeiten, wie ein Konstruktor aufgerufen werden kann:

• Implizit, durch deklarieren einer Instanz des Typs ohne es zu initialisieren
• Auch implizit, indem entweder auf das initialisieren einer Instanz mit = oder indem er eine implizite Konvertierung von Typ das argument zu Ihrer Klasse.
• Ausdrücklich den Aufruf der Konstruktor Argumente übergeben.

Welche davon Sie verwenden können, in einem bestimmten Kontext abhängt, auf die Konstruktoren, die Sie aufrufen.

class Foo 
{
    Foo();                                  //1
    Foo(int a);                             //2
    explicit foo(const std::string& f);     //3
    Foo(int c, int d);                      //4
};

1. Dieser Konstruktor aufgerufen wird, werden implizit bei der Deklaration Foo f;. Nie Versuch zu nennen, einen Konstruktor ohne Argumente explizit auf, wie Foo f(); wird deklarieren eine Funktion!
2. Diese kann aufgerufen werden, indem Sie schreiben Foo f = 42; oder Foo f(42).
3. Die explicit Schlüsselwort verbietet implizite Konvertierung durch schreiben Foo f = std::string("abc"); oder function_taking_foo(function_returning_string());.
4. Da gibt es mehrere Argumente, die explicit version ist das nur bedingt geeignet.

Wenn Sie eine Funktion, die eine Referenz auf ein Objekt der Klasse, und übergeben Sie es einem anderen Typ als Ihr Objekt der Konstruktor Ihrer Klasse zu konvertieren, dass die Art auf ein Objekt der Klasse ist. Alle ein-argument-Konstruktor wird genauso behandelt wie ein Konvertierungs-Konstruktor. Wenn erklären Sie, dass der Konstruktor explicit, dann übergeben Sie eine andere Art die anderen als Ihr Objekt, die Funktion wird nicht wandeln es und der compiler wird einen Fehler zurückgeben,