Destructor not called

[kuburoma]

Hello, i need help with destructor. I have here some kind of binary tree. This program work well, but i have a lot of memory leaks here. I made destructor. He works fine but i need to put on the end command "delete set". How it shloud works without this command?

#include <iostream>
#include <string>
#include <sstream>
#include <math.h>
#include <stdio.h>
#include <crtdbg.h>


#ifdef _DEBUG

#define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)

#define new DEBUG_NEW

#endif

using namespace std;

class Prvek {
public:

    virtual bool jeUzel() {
        return false;
    }

    virtual bool jeList() {
        return false;
    }

    virtual void zvysPocet() {
    }

    virtual Prvek * vlevo() {
        return NULL;
    }

    virtual Prvek * vpravo() {
        return NULL;
    }

    virtual void nastavLevy(Prvek * _levy) {
    }

    virtual void nastavPravy(Prvek * _pravy) {
    }

    virtual int vratPocet() {
        return 0;
    }

    virtual int vratHodnotu() {
        return 0;
    }

    virtual int vratHloubku() {
        return 0;
    }

    virtual void nastavPocet(int _pocet) {
    }

};

class Uzel : public Prvek {
    Prvek * levy;
    Prvek * pravy;
    int hloubka;

public:

	~Uzel(){
	
	}

    Uzel(int _hloubka) {
        hloubka = _hloubka;
    }

    bool jeUzel() {
        return true;
    }

    Prvek * vlevo() {
        return levy;
    }

    Prvek * vpravo() {
        return pravy;
    }

    void nastavLevy(Prvek * _levy) {
        levy = _levy;
    }

    void nastavPravy(Prvek * _pravy) {
        pravy = _pravy;
    }

    int vratHloubku() {
        return hloubka;
    }

};

class List : public Prvek {
    int pocet, hodnota;
	~List(){
	
	}

public:

    List() {
        pocet = 0;
        hodnota = 0;
    }

    List(int p) {
        pocet = 1;
        hodnota = p;
    }

    bool jeList() {
        return true;
    }

    void zvysPocet() {
        pocet++;
    }

    int vratPocet() {
        return pocet;
    }

    int vratHodnotu() {
        return hodnota;
    }

    void nastavPocet(int _pocet) {
        pocet = _pocet;
    }

};

class BSTSET {
    Prvek * koren;
    bool pokracovani;
    int hlavniCislo;
    int pocet;


public:

	virtual ~BSTSET(){
		cout << "destruktor";
        zrus();
    }

	BSTSET(){
        koren = NULL;
    }

    void zrus(){
        if(koren->jeList()){
            delete koren;
        }
        zrus(koren);
    
    }
    
    
    void zrus(Prvek * aktualni){
        if(aktualni->jeList()){
            delete aktualni;
            return;
        }
        zrus(aktualni->vlevo());
        zrus(aktualni->vpravo());
        delete aktualni;
    }

    Prvek * vratKoren() {
        return koren;
    }

    void kontrolaNejvysiho(Prvek * aktualni) {
        if (aktualni->vpravo()->jeUzel()) {
            kontrolaNejvysiho(aktualni->vpravo());
        } else {
            if (aktualni->vpravo()->vratHodnotu() < hlavniCislo) {
                Prvek * uzel = new Uzel(aktualni->vratHloubku() + 1);
                uzel->nastavPravy(new List(hlavniCislo));
                uzel->nastavLevy(aktualni->vpravo());
                aktualni->nastavPravy(uzel);
                pokracovani = false;
            }
        }
    }

    void vloz(int cislo) {
        if (koren == NULL) {
            koren = new List(cislo);
            return;
        }
        if (koren->jeUzel()) {
            hlavniCislo = cislo;
            pokracovani = true;
            kontrolaNejvysiho(koren);
            if (pokracovani) {
                vloz(koren);
            }
        } else {
            if (koren->vratHodnotu() > cislo) {
                Prvek * uzel = new Uzel(1);
                uzel->nastavPravy(koren);
                uzel->nastavLevy(new List(cislo));
                koren = uzel;
            } else {
                Prvek * uzel = new Uzel(1);
                uzel->nastavLevy(koren);
                uzel->nastavPravy(new List(cislo));
                koren = uzel;
            }
        }
    }

    void vloz(Prvek * aktualni) {
        if (pokracovani) {
            if (aktualni->vlevo()->jeList()) {
                if (aktualni->vlevo()->vratHodnotu() >= hlavniCislo) {
                    if (aktualni->vlevo()->vratHodnotu() == hlavniCislo) {
                        aktualni->vlevo()->zvysPocet();
                    } else {
                        Prvek * uzel = new Uzel(aktualni->vratHloubku() + 1);
                        uzel->nastavPravy(aktualni->vlevo());
                        uzel->nastavLevy(new List(hlavniCislo));
                        aktualni->nastavLevy(uzel);
                    }
                    pokracovani = false;
                }
            } else {
                vloz(aktualni->vlevo());
            }
            if (pokracovani) {
                if (aktualni->vpravo()->jeList()) {
                    if (aktualni->vpravo()->vratHodnotu() >= hlavniCislo) {
                        if (aktualni->vpravo()->vratHodnotu() == hlavniCislo) {
                            aktualni->vpravo()->zvysPocet();
                        } else {
                            Prvek * uzel = new Uzel(aktualni->vratHloubku() + 1);
                            uzel->nastavPravy(aktualni->vpravo());
                            uzel->nastavLevy(new List(hlavniCislo));
                            aktualni->nastavPravy(uzel);
                        }
                        pokracovani = false;
                    }
                } else {
                    vloz(aktualni->vpravo());
                }
            }
        }
    }

    void print() {
        if (koren == NULL) {
            return;
        }
        if (koren->jeList()) {
            cout << koren->vratHodnotu();
            return;
        }
        print(koren);
    }

    void print(Prvek * aktualni) {
        if (aktualni->jeList()) {
            cout << aktualni->vratHodnotu() << endl;
        } else {
            print(aktualni->vlevo());
            print(aktualni->vpravo());
        }
    }

    int hledejPocet(int _pocet) {
        if (koren == NULL) {
            return -1;
        }
        if (koren->jeList()) {
            return koren->vratPocet();
        }
        pokracovani = true;
        hledejPocet(koren, _pocet);
        if (pokracovani) {
            pocet = -1;
        }
        return pocet;
    }

    void hledejPocet(Prvek * aktualni, int _pocet) {
        if (pokracovani) {
            if (aktualni->jeList()) {
                if (_pocet == aktualni->vratHodnotu()) {
                    pocet = aktualni->vratPocet();
                    pokracovani = false;
                }
            } else {
                hledejPocet(aktualni->vlevo(), _pocet);
                hledejPocet(aktualni->vpravo(), _pocet);
            }
		}
	}
    
    int hledejHloubku(int cislo){
        return cislo;
    }
    
};

/*
 * 
 */
int main(int argc, char** argv) {

    _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );	
    
	BSTSET * set = new BSTSET();
    set->vloz(8);
    set->vloz(4);
    set->vloz(3);
    set->vloz(5);
    set->vloz(5);
    set->vloz(10);

    set->print();
    delete set;
	system("PAUSE");
	return 0;
}

[zb0S216C]

Declare the base destructor virtual.

_Wazzak

[kuburoma]

My base destructor is in class BSTSET and he is virtual.

[Peter87]

there is no subclass of BSTSET. Prvek is the base class of List and Uzel.

[kuburoma]

It is true, but when i have "Prvek" destructor virtual and rest normal it is still not working. This program is some wierd binary tree. "Uzel" is node and "List" is leaf. Node is only pointing on next two leafs or nodes. Leaf hold number. BSTSET hold pointer on root.