Initialisierung von Datenelement der Struktur in C++

Question

// Nicht in der Lage, herauszufinden, wie wir Datenelement einer Struktur innerhalb // struct initialisieren können. Ich glaube, das ist gegen die Richtlinien von OOP. Das folgende Programm zeigt keinen Compiler-Fehler und läuft Bußgelder und gibt Ausgang 10 30

#include<iostream> 
using namespace std; 
struct Accumulator 
{ 
    int counter = 0; 
    int operator()(int i) { return counter += i; } 
}; 
int main(void) 
{ 
    Accumulator acc; 
    cout << acc(10) << endl; //prints "10" 
    cout << acc(20) << endl; //prints "30" 
} 

Answer 1

, die mit dem Konstruktor getan, zu dem Sie den Anfangswert passieren können.

Etwas wie:

struct Accumulator 
{ 
    Accumulator(int initial = 0) 
     : counter(initial) 
    {} 

    int counter; 

    int operator()(int i) { return counter += i; } 
}; 

int main(void) 
{ 
    Accumulator acc(20); 
    std::cout << acc(10) << '\n'; //prints "30" 
    std::cout << acc(20) << '\n'; //prints "50" 

    // Reset accumulator 
    acc = Accumulator(); // Use constructors default argument 
    std::cout << acc(10) << '\n'; //prints "10" 
    std::cout << acc(20) << '\n'; //prints "30" 
} 

---

Wenn Sie sich fragen, warum auch ohne den Konstruktor funktioniert es, das ist, weil die Struktur ohne einen Konstruktor ein Aggregat ist und Sie können aggregate initialization verwenden.

Wenn Sie sich über die Initialisierung des counter Mitglieds wundern, dann ist es, weil es ein non-static data member ist und seit dem C++ 11 Standard können diese initialized so sein.

Answer 2

Die Regeln zur Klasseninitialisierung haben sich geändert. Beginnend in C++ 11 können Sie ein nicht statisches Klassenmitglied direkt im Klassenrumpf initialisieren. Dies ist jedoch nur syntaktischer Zucker. Wenn Sie

struct Accumulator 
{ 
    int counter = 0; 
    int operator()(int i) { return counter += i; } 
}; 

Der Compiler schreibt die Initialisierung des Zählers auf den Standard-Konstruktor tatsächlich hinzuzufügen. Also würde der obige Code in

struct Accumulator 
{ 
    int counter; 
    Accumulator() : counter(0) {} 
    int operator()(int i) { return counter += i; } 
}; 

übersetzt werden Diese Initialisierung wird auch unterdrückt, wenn Sie Ihre eigene Initialisierung liefern. Wenn wir

hatte

struct Accumulator 
{ 
    int counter = 0; 
    int sum = 0; 
    Accumulator() {} 
    Accumulator(int counter) : counter(counter) {} 
    int operator()(int i) { return counter += i; } 
}; 

Dann Accumulator() {} wäre eigentlich

Accumulator() : counter(0), sum(0) {} 

und Accumulator(int counter) : counter(counter) {} wäre

Accumulator(int counter) : counter(counter), sum(0) {}