C++ Konstruktoren vs-Initialisierung-Listen, speed-Vergleich

Gibt es Unterschiede in der Ausführungszeit zwischen Konstruktoren und Initialisierungs-Listen?(oder ist es nur eine Frage der Codierung Präferenz).
Ich habe eine Reihe von Objekten, die erstellt werden muss, die Häufig und würde gerne wissen, ob es irgendwelche performance-Gewinn durch die Verwendung von Initialisierungs-Listen anstelle von Konstruktoren.

Wenn ich erstellen Sie eine Millionen Instanzen der Klasse A und eine weitere million von Klasse B, die Wahl wäre besser(die Objekte repräsentieren-Pakete generiert, in einem Netzwerk, daher diese zahlen).

 class A {
   private:
     int a, b;

   public:
     A(int a_var, int b_var):a(a_var), b(b_var) {}; 
 };

 class B {
   private:
     int a, b;

   public:
     B(int a_var, int b_var) {
        a = a_var;
        b = b_var;
     }
};

Wenn einer der Konstruktoren ist schneller als die andere für die primitiven Typen(wie im Beispiel) wird es schneller sein, wenn a und b wurden ersetzt durch Typen?

Typ Beispiel:

 class AType {
   private:
     string a, b;

   public:
     AType(string a_var, string b_var):a(a_var), b(b_var) {}; 
};

InformationsquelleAutor der Frage Sebi | 2012-11-03

c++constructor initialization-list

Der Unterschied ist für Arten mit nicht trivialen Standard-Konstruktor, der aufgerufen wird, für die Sie vom compiler in Ihrer Klasse B. Ihre Klasse B ist äquivalent zu:

 class B {
   private:
     SleepyInt a, b;

   public:
     //takes at least 20s
     B(int a_var, int b_var) : a(), b()
     //                     ^^^^^^^^^^ 
     {
        a = a_var;
        b = b_var;
     }
  };

Wenn Sie nicht member-variable oder Basisklasse Konstruktor in der Initialisierungsliste - I der default-Konstruktor aufgerufen wird. int ist basic Art - seine Standard-Konstruktor kostet nichts - also kein Unterschied in deinem Beispiel, aber für komplexere Typen Konstruktor+Belegung Kosten vielleicht mehr als nur bauen.

Einige lustige Beispiel, nur zur Verdeutlichung des Unterschiedes:

class SleepyInt {
public:
  SleepyInt () { 
    std::this_thread::sleep_for(std::chrono::milliseconds( 10000 ));  
  }
  SleepyInt (int i) {}
  SleepyInt & operator = (int i) { return *this; }
};

class A {
   private:
     SleepyInt a, b;

   public:
     A(int a_var, int b_var):a(a_var), b(b_var) {}; 
 };

 class B {
   private:
     SleepyInt a, b;

   public:
     //takes at least 20s
     B(int a_var, int b_var) {
        a = a_var;
        b = b_var;
     }
};

InformationsquelleAutor der Antwort PiotrNycz

7

Es ist allgemein akzeptierte Praxis zu verwenden, die Initialisierung der Listen im Gegensatz zur Zuweisung im Konstruktor, und es gibt einen sehr guten Grund dafür.

Initialisierung-Listen können verwendet werden, initialisiert POD (Plain Old Data) und Benutzer-definierte Typen. Bei der Initialisierung ein POD-Typ, der Effekt ist genau das gleiche wie ein Zuweisungsoperator, d.h. es gibt keine performance-Unterschied zwischen der Initialisierung von Listen oder der Abtretung in einen Konstruktor für POD-Typen.

Wenn wir über nicht-POD-Typen werden die Dinge interessanter. Bevor der Konstruktor aufgerufen wird, werden die Konstruktoren der übergeordneten Klasse und dann alle enthaltenen Mitglieder sind aufgerufen, und standardmäßig die no-argument-Konstruktor aufgerufen wird. Mit einer Initialisierungs-Liste können Sie wählen, welcher Konstruktor aufgerufen wird.

Also um die Frage zu beantworten, gibt es einen performance-Unterschied, aber nur bei der Initialisierung nicht-POD-Typen.

InformationsquelleAutor der Antwort blockchaindev
3

Wenn Mitglieder sind mehr oder weniger komplexe Typen, so gilt die Abtretung der Initialisierung wird zunächst die Ursache der default-Konstruktor aufrufen und dann operator=die länger dauern kann.

InformationsquelleAutor der Antwort Michael Krelin - hacker
2

Wird es keine performance-Verbesserung, wenn die Typen sind built-in/Eigenwert.

Sagte:

Fazit: Alle anderen Dinge gleich sind, Ihr code wird schneller ausgeführt, wenn
verwenden Sie die Initialisierung Listen eher als Zuordnung.

InformationsquelleAutor der Antwort Science_Fiction

Initialisierung Liste positiver Referenz-Typen, member-Objekte der Klasse oder const Mitglieder. Sonst braucht es mehr Zeit.

Blick auf mein test-code:

#include <iostream>
#include <ctime>

using namespace std;

class A{
    int a;
public:
    A(int a_):a(a_){}
};

class B{
    int b;
public:
    B(){
    }

    B(int b_){
        b=b_;
    }
};

class C{
    B b;
public:
    C(int c_):b(c_){
    }
};

class D{
    B b;
public:
    D(int d_){
        b=d_;
    }
};

int main()
{
    clock_t start1[10], start2[10], end1[10], end2[10];
    for(int j=0;j<10;j++){
        start1[j]=clock();
        for(int i=0;i<100000;i++){   
            A *newA=new A(i);
            delete newA;
        }
        end1[j]=clock();
        start2[j]=clock();
        for(int i=0;i<100000;i++){   
            B *newB=new B(i);
            delete newB;
        }
        end2[j]=clock();
    }
    double avg1=0, avg2=0;
    for(int i=0;i<10;i++){
        avg1+=(end1[i]-start1[i]);
        avg2+=(end2[i]-start2[i]);
    }
    cout << avg1/avg2 << endl;

    for(int j=0;j<10;j++){
        start1[j]=clock();
        for(int i=0;i<100000;i++){   
            C *newC=new C(i);
            delete newC;
        }
        end1[j]=clock();
        start2[j]=clock();
        for(int i=0;i<100000;i++){   
            D *newD=new D(i);
            delete newD;
        }
        end2[j]=clock();
    }
    avg1=avg2=0;
    for(int i=0;i<10;i++){
        avg1+=(end1[i]-start1[i]);
        avg2+=(end2[i]-start2[i]);
    }
    cout << avg1/avg2 << endl;

    system("pause");
    return 0;
}

Beispiel Ausgaben wie diese:

1.02391

0.934741

InformationsquelleAutor der Antwort Oğuzhan Türk

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.