Konstruktory i destruktory klasy będącej wskaźnikiem na klasę

Question

Cześć,

próbuję zrozumieć część poniższego kodu, a dokładnie:

CFooSmartPtr(CFoo* pFoo) : m_pWskaznik(pFoo) { cout << "Konstruktor klasy CFooSmartPtr" << endl; }

Czy mógłby mi ktoś to przetłumaczyć? Rozumiem, że CFooSmartPtr(CFoo* pFoo) to konstruktor klasy CFooSmartPtr, którego argumentem formalnym jest CFoo* pFoo, czyli wskaźnik na klasę CFoo.

natomiast co oznacza to dalej po dwukropku?

Program działa także jak zamiast powyższego wstawię coś takiego:

CFooSmartPtr(CFoo*wsk) { m_pWskaznik = wsk; cout << "Konstruktor klasy CFooSmartPtr" << endl; }

Czy są to analogiczne działania?

#include <iostream>

using namespace std;

class CFoo {

public:

// konstruktor i destruktor

int power;
int dex;
int wisdom;

    CFoo () {

    cout << "Konstruktor klasy CFoo" << endl;

    power = 100;
    dex = 120;
    wisdom = 80;

    }

    ~CFoo () {

    cout << "Destruktor klasy CFoo" << endl;

    }




};

class CFooSmartPtr
{
private:

CFoo* m_pWskaznik; // m_pWskaznik jest wskaźnikiem na obiekt klasy CFoo

public:
// konstruktor i destruktor

CFooSmartPtr(CFoo* pFoo) : m_pWskaznik(pFoo) { cout << "Konstruktor klasy CFooSmartPtr" << endl; }
~CFooSmartPtr() { if (m_pWskaznik) delete m_pWskaznik; cout << "Destruktor klasy CFooSmartPtr" << endl; }

//-------------------------------------------------------------

// operator dereferencji
CFoo& operator*() { return *m_pWskaznik; }
// operator wyłuskania
CFoo* operator->() { return m_pWskaznik; }

};


int main () {

try
{
CFooSmartPtr pFoo = new CFoo;

cout << pFoo->power << endl;
cout << pFoo->dex << endl;
cout << pFoo->wisdom << endl;

// ...
throw "Cos sie stalo";
// niszczony obiekt pFoo i wywoływany destruktor CFooSmartPtr

} catch (const char* e) {

cout << e << endl;

}

string temp;
getline(cin,temp);



}

 

Answer 1

Operacje po dwukropku to bezpośrednia inicjalizacja zmiennych klasy.

class Osoba {
private:
   std::string mImie;
   std::string mNazwisko;
   const int mRokUrodzenia;
public:
    Osoba(const char* imie, const char* nazwisko, int rokUrodzenia) :
        mImie(imie),
        mNazwisko(nazwisko),
        mRokUrodzenia(rokRurodzenia) 
    {
    }
}

W ten sposób unikasz niepotrzebnego wywoływania konstruktorów domyślnych pól składowych klasy. Tylko w ten sposób możesz ustawić wartość stałych pól klasy (patrz mRokUrodzenia)

Answer 2

Tak jak przedmówca powiedział po dwukropku występuje inicjalizacja zmiennych klasy oraz możesz wywołać odziedziczony konstruktor z klasy bazowej. Taką składnie często wykorzystuje się w frameworku C++/Qt gdzie występuje hierarchia typów. Przykład:

StyledItemDelegate::StyledItemDelegate(QObject *parent) : QStyledItemDelegate(parent)
{
//Ciało konstruktora
}

Jeszcze z rzeczy podstawowych to przy takim typie inicjalizacji powinieneś zachować kolejność deklaracji zmiennych taką samą jak w klasie.

class Osoba {
private:
   std::string mImie;
   std::string mNazwisko;
   const int mRokUrodzenia;
public:
    Osoba(const char* imie, const char* nazwisko, int rokUrodzenia) :
        mRokUrodzenia(rokRurodzenia) ,
       mNazwisko(nazwisko),
        mImie(imie)
    {
//Niezachowana kolejność
    }

Więcej informacji

https://en.cppreference.com/w/cpp/language/initializer_list