Aufruf von Konstruktor nach Objekt Definition

Question

class first{ 
    int fa,fb; 

    public: 
     first(); 
     first(int x,int y); 
     void display(); 
}; 

first::first():fa(0),fb(0){ 
     } 

first::first(int x,int y):fa(x),fb(y){ 
} 

void first::display(){ 
    cout<<fa<<" "<<fb; 
} 

class second{ 
    first f; 
    int sa,sb; 

    public: 
     second(); 
     second(int x,int y,int a,int b); 
     void display(); 
}; 

second::second():sa(0),sb(0){ 
} 

second::second(int x,int y,int a,int b):f(x,y),sa(a),sb(b){ 
} 

void second::display(){ 
    cout<<"The Numbers are "; 
    f.display(); 
    cout<<" "<<sa<<" "<<sb<<endl; 
} 

Ich entschuldige mich, wenn diese Frage bereits gestellt wurde.

Dies ist ein einfacher Code, um das Arbeiten von verschachtelten Klassen in C++ zu demonstrieren. Jedoch in der Klasse second, das Objekt f, obwohl es zuvor definiert wurde, kann ich einen Konstruktor darauf unter Verwendung der Konstruktor second Klasse aufrufen. Wie ist es möglich, einen Konstruktor für eine bereits definierte Instanz einer Klasse aufzurufen?

Answer 1

Das Objekt first f; ist ein Mitglied von second. Das heißt, jeder second enthält einen first. Daher muss beim Erstellen eines second ein first erstellt werden. Ihr Mem-Initialisierer f(x,y) legt genau fest, wie f erstellt wird, während das Objekt second erstellt wird.

Answer 2

Sie verschiedene Konzepte mischen, wenn eine Variable in einer Funktion definiert:

void foo() 
{ 
    Foobar f; // f is defined and default initialized here 
    Foobar d { 123 }; // d is defined and initialized with 123 
} 

und als ein Feld innerhalb eines class oder struct erklärt:

struct boo { 
    Foobar f; // f is declared as member of type boo and how it will be 
       // initialized will be known in boo's constructor 
       // not here 

    boo() {} // f is default constructed 
    boo(int i) : f { i } {} // f is initialized with i 
}; 

, um die Dinge schlimmer für Sie in C++ 11 Sie können Parameter an den Feldkonstruktor übergeben:

struct boo { 
    Foobar d { 123 }; // d would be initialized with 123 if otherwise is not set in boo's constructor 

    boo(int i) : d { i } {} // 123 is ignored and d is initialized with i 
    boo() {} // d { 123 } is used 
}; 

so noch, auch wenn Sie Parameter an Feld übergeben, wie Feld initialisiert wird, ist in boo's Konstruktor definiert.