Was ist diese seltsame Doppelpunkt-Member-Syntax (” : “) im Konstruktor?

Kürzlich habe ich ein Beispiel wie das folgende gesehen:

#include <iostream>

class Foo {
public:
  int bar;
  Foo(int num): bar(num) {};
};

int main(void) {
  std::cout << Foo(42).bar << std::endl;
  return 0;
}

Was bedeutet das seltsam : bar(num) bedeuten? Es scheint irgendwie die Member-Variable zu initialisieren, aber ich habe diese Syntax noch nie zuvor gesehen. Es sieht aus wie ein Funktions-/Konstruktoraufruf, aber für eine int? Macht für mich keinen Sinn. Vielleicht könnte mich jemand aufklären. Und übrigens, gibt es noch andere esoterische Sprachfeatures wie diese, die Sie niemals in einem gewöhnlichen C++-Buch finden werden?

Foo(int num): bar(num)    

Dieses Konstrukt heißt a Mitgliedsinitialisiererliste in C++.

Einfach gesagt, es initialisiert Ihr Mitglied bar zu einem Wert num.

Was ist der Unterschied zwischen Initialisierung und Zuweisung innerhalb eines Konstruktors?

Member-Initialisierung:

Foo(int num): bar(num) {};

Mitgliedszuweisung:

Foo(int num)
{
   bar = num;
}

Es besteht ein wesentlicher Unterschied zwischen dem Initialisieren eines Members mithilfe der Member-Initialisierungsliste und dem Zuweisen eines Werts innerhalb des Konstruktorkörpers.

Wenn du initialisieren Felder über die Member-Initialisierungsliste werden die Konstruktoren einmal aufgerufen und das Objekt wird in einer Operation konstruiert und initialisiert.

Wenn du benutzt Abtretung dann werden die Felder zuerst mit Standardkonstruktoren initialisiert und dann (über den Zuweisungsoperator) mit tatsächlichen Werten neu zugewiesen.

Wie Sie sehen, gibt es in letzterem einen zusätzlichen Aufwand für die Erstellung und Zuweisung, der für benutzerdefinierte Klassen erheblich sein kann.

Cost of Member Initialization = Object Construction 
Cost of Member Assignment = Object Construction + Assignment

Letzteres ist eigentlich äquivalent zu:

Foo(int num) : bar() {bar = num;}

Während ersteres gleichbedeutend ist mit:

Foo(int num): bar(num){}

Für einen eingebauten (Ihr Codebeispiel) oder POD-Klassenmember gibt es keinen praktischen Overhead.

Wann MÜSSEN Sie die Member Initializer-Liste verwenden?

Du wirst haben (eher gezwungen). Verwenden Sie eine Member-Initialisierungsliste, wenn:

• Ihre Klasse hat ein Referenzelement
• Ihre Klasse hat ein nicht statisches Konstantenmitglied oder
• Ihr Klassenmitglied hat keinen Standardkonstruktor oder
• Zur Initialisierung von Basisklassenmitgliedern oder
• Wenn der Parametername des Konstruktors mit dem Datenelement identisch ist (dies ist nicht wirklich ein MUSS)

Ein Codebeispiel:

class MyClass {
public:
  // Reference member, has to be Initialized in Member Initializer List
  int &i;
  int b;
  // Non static const member, must be Initialized in Member Initializer List
  const int k;

  // Constructor’s parameter name b is same as class data member
  // Other way is to use this->b to refer to data member
  MyClass(int a, int b, int c) : i(a), b(b), k(c) {
    // Without Member Initializer
    // this->b = b;
  }
};

class MyClass2 : public MyClass {
public:
  int p;
  int q;
  MyClass2(int x, int y, int z, int l, int m) : MyClass(x, y, z), p(l), q(m) {}
};

int main() {
  int x = 10;
  int y = 20;
  int z = 30;
  MyClass obj(x, y, z);

  int l = 40;
  int m = 50;
  MyClass2 obj2(x, y, z, l, m);

  return 0;
}

• MyClass2 hat keinen Standardkonstruktor, daher muss er über die Member-Initialisierungsliste initialisiert werden.
• Basisklasse MyClass hat keinen Standardkonstruktor. Um sein Mitglied zu initialisieren, muss also die Member Initializer List verwendet werden.

Wichtige Punkte, die bei der Verwendung von Member Initializer Lists zu beachten sind:

Klassenmember-Variablen werden immer in der Reihenfolge initialisiert, in der sie in der Klasse deklariert werden.

Sie sind nicht in der Reihenfolge initialisiert, in der sie in der Member-Initialisierungsliste angegeben sind.
Kurz gesagt, die Member-Initialisierungsliste bestimmt nicht die Reihenfolge der Initialisierung.

In Anbetracht des Obigen ist es immer eine gute Praxis, die gleiche Reihenfolge der Member für die Member-Initialisierung beizubehalten wie die Reihenfolge, in der sie in der Klassendefinition deklariert sind. Dies liegt daran, dass Compiler nicht warnen, wenn die beiden Reihenfolgen unterschiedlich sind, aber ein relativ neuer Benutzer könnte die Member-Initialisiererliste mit der Reihenfolge der Initialisierung verwechseln und davon abhängigen Code schreiben.

Es ist ein Member-Initialisierungsliste. Informationen darüber sollten Sie in jedem guten C++-Buch finden.

In den meisten Fällen sollten Sie alle Member-Objekte in der Member-Initialisierungsliste initialisieren (beachten Sie jedoch die am Ende des FAQ-Eintrags aufgeführten Ausnahmen).

Der Takeaway-Punkt aus dem FAQ-Eintrag ist, dass

Wenn alle anderen Dinge gleich sind, wird Ihr Code schneller ausgeführt, wenn Sie Initialisierungslisten anstelle von Zuweisungen verwenden.

Das ist die Konstruktorinitialisierung. Es ist der richtige Weg, Member in einem Klassenkonstruktor zu initialisieren, da es verhindert, dass der Standardkonstruktor aufgerufen wird.

Betrachten Sie diese beiden Beispiele:

// Example 1
Foo(Bar b)
{
   bar = b;
}

// Example 2
Foo(Bar b)
   : bar(b)
{
}

In Beispiel 1:

Bar bar;  // default constructor
bar = b;  // assignment

In Beispiel 2:

Bar bar(b) // copy constructor

Es geht um Effizienz.

Dies wird als Initialisierungsliste bezeichnet. Es ist eine Möglichkeit, Klassenmitglieder zu initialisieren. Es hat Vorteile, dies zu verwenden, anstatt den Mitgliedern im Hauptteil des Konstruktors einfach neue Werte zuzuweisen, aber wenn Sie Klassenmitglieder haben, die vorhanden sind Konstanten oder Verweise Sie Muss initialisiert werden.

Das ist nicht obskur, es ist das Syntax der C++-Initialisierungsliste

Grundsätzlich gilt in Ihrem Fall x wird mit initialisiert _x, y mit _y, z mit _z.

Der andere hat Ihnen bereits erklärt, dass die von Ihnen beobachtete Syntax “Konstruktorinitialisiererliste” heißt. Mit dieser Syntax können Sie Basis-Unterobjekte und Mitglieds-Unterobjekte der Klasse benutzerdefiniert initialisieren (im Gegensatz dazu, dass sie standardmäßig initialisiert werden oder nicht initialisiert bleiben).

Ich möchte nur darauf hinweisen, dass die Syntax, die, wie Sie sagten, “wie ein Konstruktoraufruf aussieht”, nicht unbedingt ein Konstruktoraufruf ist. In der Sprache C++ ist die () Syntax ist nur eine Standardform von Initialisierungssyntax. Es wird für verschiedene Typen unterschiedlich interpretiert. Für Klassentypen mit benutzerdefiniertem Konstruktor bedeutet es eine Sache (es ist tatsächlich ein Konstruktoraufruf), für Klassentypen ohne benutzerdefinierten Konstruktor bedeutet es etwas anderes (sog Wertinitialisierung ) für leer ()) und für Nicht-Klassen-Typen bedeutet es wieder etwas anderes (da Nicht-Klassen-Typen keine Konstruktoren haben).

In Ihrem Fall hat das Datenelement Typ int. int ist kein Klassentyp, hat also keinen Konstruktor. Für Typ int Diese Syntax bedeutet einfach “initialisieren bar mit dem Wert von num” und das war’s. Es wird einfach so gemacht, direkt, keine Konstrukteure beteiligt, denn noch einmal, int ist kein Klassentyp und kann daher keine Konstruktoren haben.

Ich weiß nicht, wie man das übersehen könnte, es ist ziemlich einfach. Das ist die Syntax zum Initialisieren von Mitgliedsvariablen oder Basisklassenkonstruktoren. Es funktioniert sowohl für einfache alte Datentypen als auch für Klassenobjekte.