bisher habe ich ein delete so gemacht:

//Aufruf zum delete

Hash_Table<T>* ht = NULL;
//Mache was mit ht - fülle es z.B

ht->Delete_Hash_Table(ht);

//jetzt die delete methode
template<class T>	void
Hash_Table<T>::Delete_Hash_Table(Hash_Table<T> *ht)
{
	if (ht) 
	{
		for (int i = 0; i < ht->size; i++) 
		{
			if (ht->col_idcs_table[i]) 
				delete [] ht->col_idcs_table[i];
			if (ht->row_idcs_table[i]) 
				delete [] ht->row_idcs_table[i];
			if (ht->vals_table[i]) 
				delete [] ht->vals_table[i];
		}
		delete [] ht->col_idcs_table;
		delete [] ht->row_idcs_table;
		delete [] ht->vals_table;
		delete ht;
	}
}

Ich meine aber, dass es da es member sind auch so geht:

Hash_Table<T>* ht = NULL;
//Mache was mit ht - fülle es z.B

ht->Delete_Hash_Table();

template<class T>	void
Hash_Table<T>::Delete_Hash_Table()
{
	if (this) 
	{
		for (int i = 0; i < size; i++) 
		{
			if (col_idcs_table[i]) 
				delete [] col_idcs_table[i];
			if (row_idcs_table[i]) 
				delete [] row_idcs_table[i];
			if (vals_table[i]) 
				delete [] vals_table[i];
		}
		delete [] col_idcs_table;
		delete [] row_idcs_table;
		delete [] vals_table;
		delete this;
	}
}

Mir geht es jetzt darum: Ist das if(this) hier korrekt? Also wäre das auch ein pointer?
Ist denn über den Aufruf ht->Delete_Hash_Table(); klar, dass die member von diesem ht und nicht z.B eines anderen ht2 gelöscht werden?
wäre das so in Ordnung?

Danke

Mir geht es jetzt darum: Ist das if(this) hier korrekt? Also wäre das auch ein pointer?

Ich würde eher ein assert nehmen, wenn überhaupt Und ja, der this-Zeiger kann auch NULL sein, etwa hier:

Hash_Table<T>* ht = NULL;
ht->Delete_Hash_Table();

gast_xy schrieb:

Ist denn über den Aufruf ht->Delete_Hash_Table(); klar, dass die member von diesem ht und nicht z.B eines anderen ht2 gelöscht werden?
wäre das so in Ordnung?

Ich denke du solltest es eher über einen Destruktor machen, die gibts ja nicht umsonst. Wird z.B. das Hash-Table-Objekt auf dem Stack angelegt Hash_Table<T> ht; , dann schlägt delete this; natürlich fehl! Von daher: Die ganzen delete-Sachen in den Destruktor packen, dann muss aber ein mit new erzeugtes Hash-Table auch mit delete wieder zerstört werden.

ht->~Delete_Hash_Table();

Prinzipiell ging es mir hauptsächlich darum, ob so auch korrekt auf die Membervariablen zugegriffen wird. Also ich wollte wissen ob ich denn das *ht überhaupt übergeben sollte oder ob das sowieso aus dem aufruf ht->fct() klar hervorgeht.
Mit anderen worten:

Hash_Table<T>* ht1, *ht2;

ht1->fct(); //verändert doch nur die member von OBjekt ht1 oder?
ht2->fct(); //verändert doch nicht die member von ht1, sondern seine eigenen oder?

also der pointer-aufruf ist eindeutig oder?

Weitere frage:

folgendes:

Hash_Table<T> ht = Hash_Table<T>();

ht.~Delete_Hash_Table();

// wird hier trotzdem in den if-zweig des delete geprungen? Ja oder, ein statisches Objekt ist ungleich NULL oder?

Und wegen Kon- und Destruktor-Aufrufen: Das geht auch alles von alleine. Du hast zwei Möglichkeiten, du kannst Objekte auf dem Stack oder auf dem Heap ablegen.
Stack:

void SomeFunction()
{
    Hash_Table<int> ht(); // Hier wird der Konstruktor aufgerufen, () kannst du auch weglassen
    ht.BlaBla();
    // Hier ist der "Scope" vorbei, das Objekt ht wird zerstört, der Destruktor wird automatisch aufgerufen
}

Heap:

void SomeFunction()
{
    Hash_Table<int>* ht = new Hash_Table<int>(); // Hier wird Speicher angefordert und der Konstruktor aufgerufen
    // ht ist hier nur ein Zeiger auf das Objekt, nicht das Objekt selber
    // Das bedeutet, am Ende vom Block/Scope wird nicht automatisch der Destruktor aufgerufen, also:
    delete ht; // Destruktor wird aufgerufen und der Speicher wieder freigegeben
}

Der Vorteil, Variablen auf dem Heap freizugeben, ist, dass sie eben nicht beim Verlassen des Blocks kaputtgemacht werden. D.h. du kannst den Zeiger rumreichen und das Objekt dahinter erstellen und zerstören wann du willst

Achso, und deine Klasse könnte dann so aussehen:

template<class T> class Hash_Table
{
    public:
        Hash_Table() // Konstruktor
        {
            // Hier kannst du alle deine Member-Variablen erstellen, z.B.
            col_idcs_table = new T[100];
        }

        ~Hash_Table()
        {
            for (int i = 0; i < size; i++)
            {
                if (col_idcs_table[i])
                    delete [] col_idcs_table[i];
                if (row_idcs_table[i])
                    delete [] row_idcs_table[i];
                if (vals_table[i])
                    delete [] vals_table[i];
            }
            delete [] col_idcs_table;
            delete [] row_idcs_table;
            delete [] vals_table;
            //delete this; das brauchst du jetzt nicht mehr :)
        }

    private:
        T* col_idcs_table;
        T* row_idcs_table;
};

Ich würde eher ein assert nehmen, wenn überhaupt Und ja, der this-Zeiger kann auch NULL sein, etwa hier:

Hash_Table<T>* ht = NULL;
ht->Delete_Hash_Table();

Der Aufruf erzeugt schon undefiniertes Verhalten. Du landest zwar in der Praxis bei nicht-virtuellen Funktionen tatsächlich in der Methode mit this==0, aber toller Stil ist das nicht gerade. Das assert gehört VOR den Aufruf der Methode.

Kann ihc denn an einen destruktor auch parameter übergeben:
~Destructor(int num); ?

ne

Index_Set *a = NULL;

delete a;

Index_Set::Index_Set(int len_a)
{
	idcs = NULL;
	len = len_a;
	idcs = new int[len];
}

Index_Set::~Index_Set()

{
        if(idcs)
	    delete [] idcs;
}

// idcs sind als member : int * idcs;

Index_Set *a = NULL;
delete a;

Löschen eines Null-Zeigers. Kein Problem Darfst a nur nicht dazwischen nutzen!

Index_Set::Index_Set(std::size_t len) : m_len(len)
{
    m_idcs = new int[len];
}

geht auch len muss aber positive Ganzzahl sein. D.h. std::size_t ...

Index_Set::~Index_Set()
{
    delete [] m_idcs;
}

NULL-Zeiger führen nicht zu undefiniertem Verhalten. Das ist auch i.O.
=>Sollte d.h. so gehen

Warum geht denn das folgende nicht ohne speicherleck:

In dem Codestück passiert garnichts... Wo siehst Du ein Speicherleck?

Index_Set* a = NULL;

Index_Set* b = NULL;

b = new Index_Set(5);
b->idcs[0] = 0;
//fülle b weiter

a = b;

//hier verursacht ein delete a Probleme? Evtl. weil nur der Pointer gelöscht wird?
delete a;

Wenn Du Zeiger im Objekt hast (wie idcs), musst Du diese selbst verwalten, sprich löschen wie in Deinem vorletzten Beispiel mit delete im Destruktor. Damit sollte Dein Code keinerlei Probleme machen.

bevor ich etwas ändere, habe ich wirklich ein speicherleckfreies programm.

Sobals ich NUR diesen destruktor reinbaue OHNE dass er aufgerufen wird. Es wird immer noch Index_Set::Delete_Index_Set(Index_Set* is) aufgerufen!!!
Aber so bekomme ich 8000 errors:

Index_Set::~Index_Set()

{
        if (idcs)
	     delete [] idcs;
}

Ich initialisiere meine Index_Set pointer nur so:

Index_Set * a = NULL;
a = new Index_Set(...);

//Mein Konstruktor:
Index_Set::Index_Set(int len_a)
{
	idcs = NULL;
	len = len_a;
	idcs = new int[len];
}

das kann doch nicht sein

Conditional jump or move depends on uninitialised value(s)
==9597==    at 0x8052FAA: Index_Set::~Index_Set() ....in..

Index_Set** j_sets;

//j_sets wird initialisiert

Index_Set *a = NULL;
a = new Index_Set(3);
j_sets[0] = a;

Index_Set *b = NULL;
b = j_sets[0];

//das folgende delete geht nicht mehr ohne probleme - WARUM?
delete b;

Index_Set** ptr_array_set = new Index_Set*[1]; // !!! Muss schon auf was zeigen ;) !!!

Index_Set* ptr_a = new Index_Set(3);
ptr_array_set[0] = ptr_a;

Index_Set* ptr_b = ptr_array_set[0];
delete ptr_b;
ptr_b = NULL; // s.u.
ptr_a = NULL; // damit man nicht mehr in Versuchung kommt ptr_a zu nutzen :P
delete [] ptr_array_set; // muss auch wieder freigegeben werden!

warum geht dann folgendes nicht und wie kann ich es lösen?:

Index_Set * a = NULL;

for ( int i = 0; i < 5; i++)
{
   //Get_Index_Set funktioniert !!!!
   a = Get_Index_Set(...);

   //mache was mit a

   if (//some_condition)
        break;

   delete a;
}
//hier muss das delete weg - aber wenn die break anweisung kommt 
//kann ich nicht einfach hier das delete hinmachen anstatt vor die break-anweisung?
delete a;

Index_Set * a = NULL;
for (std::size_t i = 0; i < 5; ++i)
{
   a = get_index_set(...);
   if ( ... )
        break;

   delete a;
}

delete a; // delete NULL ist definiert.

...

Index_Set * a = NULL;

for ( int i = 0; i < 5; i++)
{
   //Get_Index_Set funktioniert !!!!
   a = Get_Index_Set(...);

   //mache was mit a

   if (//some_condition)
   {
        delete a;
        break;
    }

   delete a;
}

get_index_set sieht so aus:

Index_Set* Class:Get_Index_Set(int i)
{
Index_Set * is = NULL;

//is wird geholt // so ungefähr aber korrekt:
is = j_sets[i];

return is;
}

Index_Set o_is;

nach dem fkt-scope wird da ja auch der destruktor aufgerufen der ja idcs löscht.
Da aber o_is den standard-konstruktor aufruft der leer ist bei mir, wird auch kein idcs initialisiert

Oh man....sein ein mist....

danke für die geduld und Hilfe.

...

Index_Set* ptr = NULL;
for (std::size_t i = 0; i < 5; ++i)
{
    ptr = get_index_set(...);

    if (/* ... */)
        break;

    delete ptr;
    ptr = NULL;
}
delete ptr;

sollte gehen ...

Also wenn ich folgendes habe:

class A
{
      public:
            A() {  };
            A(int num);

           ~A();

            int * a;
};

// implementierung
A::A(int num)
{
       a = new int[num];
}

A::~A()
{
     delete [] a;
}

Wie sollte denn sowas dann gehen?

//irgendwo:
void B::fct()
{
    A o_a;
     //nach dem verlassen gibts doch hier nen seg-fault
     //aber wie sollte ich dann statsiche objekte initialisieren?

    // So müsste ich ja immer das hier schreiben:
    int dummy = 0;
    A o_a = A::A(dummy);    

}

Oder verstehe ich da irgendwas nicht so ganz?

Oder verstehe ich da irgendwas nicht so ganz?

Scheinbar. Fang besser nochmal ganz vorne bei Lebensdauer und Scopes an. Denn Deine Fragen sind konfus und ergeben sehr wenig Sinn.