wywoływanie destruktora.

Question

Cześć, czy wie ktoś czy można "panować" nad wywoływaniem destruktora? Destruktor wywołuje się w momencie niszczenia obiektu, czyli również w czasie trwania programu np. kiedy wywołujemy funkcje w której tworzymy obiekt klasy posiadającej destruktor. Chciałbym żeby destruktory tych obiektów(z funkcji) były wywoływane na końcu programu, czy jest to możliwe?

#include <iostream>
using namespace std;

class klasa {
private: 
	int* x;
public:
	klasa()
	{
		x = new int[3];
	}
	klasa& fun()
	{
		klasa A;
		return A;
	}
	~klasa()
	{
		delete x;
		cout << " usunieto " << endl;
	}
};
int main()
{
	klasa B;
	B.fun();
// wywolanie destruktora 1
	B.fun();
// wywolanie destruktora 2

	return 0;
// wywolanie destruktora obiektu B
// i tutaj chcialbym zeby byly wywolane destruktory 1 i 2
}

Przykładowy program pokazujący o co chodzi

Comments

Według opisu @mokrowski i @profesorek96 

#include <iostream>
using namespace std;
  
class moja_klasa {
    private: 
        int* x;
        char* ch_;
    public:
        moja_klasa(char ch) {
            x = new int[3];
            ch_ = new char(ch);
            cout << "Konstruktor dla: " << ch_ << endl;
        }
        moja_klasa& fun()
        {
            cout << " wywolano fun() dla: " << ch_ << endl;
            return *this;
        }
        ~moja_klasa()
        {
            delete [] x;
            cout << "Destruktor dla: " << ch_ << endl;
        }
};
    
int main()
{
    moja_klasa *a = new moja_klasa('a');
    a->fun();
    // wskazówka: @profesorek96
    // wywołanie destruktora - "świadome"
    // musi nastąpić po użyciu operatora new
    // zapobieganie "wyciekaniu pamięci"
    delete a;
    
    cout << endl;
    
    moja_klasa b('b');
    moja_klasa c('c');
    b.fun();
    c.fun();
    
    cout << "\nKoniec programu\n";
    
    // // wskazówka: @mokrowski
    // tu następuje automatyczne zniszczenie (wywołanie destruktora)
    // w odwrotnej kolejności niż kreacja.
    // czyli c, później b
    
    return 0;
}

 

Answer 1

Ależ one w podanym przykładzie, właśnie są wywoływane na końcu programu:

#include <iostream>
using namespace std;
 
class klasa {
private: 
    int* x;
public:
    klasa()
    {
        x = new int[3];
    }
    klasa& fun()
    {
        return *this;
    }
    ~klasa()
    {
        delete [] x;
        cout << " usunieto " << endl;
    }
};
int main()
{
    klasa a;
    klasa b;
    a.fun();
    b.fun();
    cout << "Koniec programu\n";
    // Tu następuje zniszczenie w odwrotnej kolejności niż kreacja.
    // Czyli b a później a
}

 

Comments

#include <iostream>
using namespace std;

class klasa {
private: 
	int* x;
public:
	klasa()
	{
		x = new int[3];
	}
	klasa& fun()
	{
		klasa A;
		return A;
	}
	~klasa()
	{
		delete x;
		cout << " usunieto " << endl;
	}
};
int main()
{
	int a;
	klasa B;
	B.fun();
	B.fun();
	cin >> a;

	return 0;
}

No właśnie że nie zobacz że zanim wprowadzisz jakąś liczbę do 'a' już pojawiają się 2 komunikaty "usunięto" dotyczące dwukrotnego wywołania funkcji.

---

Możesz sprawdzić czym różni się mój kod od Twojego?

Co masz w linii 14 swojego kodu?

A linia 19? Jak usuwasz tablicę?

Answer 2

Zacznijmy od tego że w języku C++ mamy cztery rodzaje pamięci:

• Pamięć automatyczn
• Pamięć dynamiczn
• Pamięć statyczn
• Pamięć wątku

Pamięci wątku oraz statycznej nie będę omawiał. Zajmiemy się tylko pamięcią automatyczna i dynamiczną. Pierwsza z nich czyli pamięć automatyczna to nic innego jak zmienne „zwykłe” czyli np int x, zmienna  x należy do pamięci automatycznej, tak samo Moja_klasa k to również pamięć automatyczna. Pamięć ta charakteryzuje się tym że zmienne należące do tego rodzaju pamięci są automatycznie usuwane po wyjściu z bloku kodu lub funkcji.
Pamięć dynamiczna to wszystko co tworzymy za pomocą operatora new, zmienne, obiekty będą żyły, zajmowały zasoby dopóki nie zostanie pamięć na nasze życzenie zwolniona za pomocą operatora delete.

Oczywiści zasoby zarezerowane za pomocą new zostaną zwolnione przez system po zakończeniu programu.

Weźmy taki program:

#include <iostream>
using namespace std;    

class Moja_klasa
{
    public:
    Moja_klasa()
    {
        cout<<"Konstruktor"<<endl;
    }
    ~Moja_klasa()
    {
        cout<<"Destruktor"<<endl;
    }
};
int main()
{
    Moja_klasa moja;
    return 0;
}

Uruchamiając ten program naszym oczom ukaże się napis Konstruktor, a zaraz pod nim Destruktor. W funkcji main tworzymy obiekt  moja, dlatego wywołuje się konstruktor zaś zaraz po tym funkcja main się kończy więc nasz obiekt jest niszczony.
Proponuję teraz zmodyfikować nasz program na taki:

#include <iostream>
using namespace std;    

class Moja_klasa
{
    public:
    Moja_klasa()
    {
        cout<<"Konstruktor"<<endl;
    }
    ~Moja_klasa()
    {
        cout<<"Destruktor"<<endl;
    }
};
int main()
{
    Moja_klasa *moja=new Moja_klasa();
    return 0;
}

W tym przypadku tworzymy obiekt dynamicznie za pomocą operatora new. Jak pewnie zauważyłeś na standardowe wyjście wypisuje się tylko napis Konstruktor oznaczający ze tylko konstruktor został wykonany. Jest to jak najbardziej normalne, operator new powoduje wysłanie konstruktora. Jeśli chcieli byśmy zwolnić zasoby, zarazem wywołać destruktor powinniśmy użyć operatora delete. Zobaczymy więc na kolejny przykład:

#include <iostream>
using namespace std;    

class Moja_klasa
{
    public:
    Moja_klasa()
    {
        cout<<"Konstruktor"<<endl;
    }
    ~Moja_klasa()
    {
        cout<<"Destruktor"<<endl;
    }
};
int main()
{
    Moja_klasa *moja=new Moja_klasa();
    delete moja;
    return 0;
}

Teraz naszym oczom powinien ukazać się zarówno napis Konstruktor jak i Destruktor. Zasadniczo konstruktor jest to metoda która „konfiguruje”, przygotowuje nasz obiekt do działania, istnienia. Zaś destruktor to metoda która sprząta po obiekcie, to właśnie w nim powinna znaleść się realokacja pamięci zablokowanej przez konstruktor czy zakończenia połączenia z bazą danych.
Operator new jak i delete stanowią parę, pierwszy z nich wywołuj konstruktor zaś drugi destruktor. Ponadto odpowiednio rezerwują pamięć, oraz ja dealokują. Nigdy nie wolno mieszać operatora new i delete z funkcjami pochodzącymi z języka C takimi jak malloc, calloc, realloc czy free. Jeśli tworzymy obiekt za pomocą new nie możemy go usunąć funkcja free, to samo jeśli tworzymy obiekt funkcją malloc nie możemy go zwolnić operatorem delete. Nie zwolnienie zasobów stworzonych w pamięci dynamicznej może skutkować wyciekiem pamięci. Pamiętaj również że jednemu operatorowi new powinien odpowiadać jeden operator delete. Nie można kilkakrotnie usuwać już zwolnione pamięci jak i tworzyć kilkukornie nowego obszaru pamięci bez uprzednio zwolnienia starego.

Answer 3

Ogólnie to destruktor możesz wywołać sam ale i tak on zostanie wywolany przy wyjściu zmiennej ze scope'u. Jakbyś chciał żeby ta klasa B odpowiadała za tworzenie tych obiektów i żeby z nią je zniszczyć to musiałbyś dodawać te obiekty np. jako smartpointery do jakiejś tablicy w  klasie B i zwracać do nich referencje. Wtedy te obiekty nie zginą póki B nie zostanie usunięte.