delete von klassenvariablen

so gehts - aber WARUM denn?

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;
}

Es lag doch an was ganz anderem . Ich habe auch Objekte so initialisiert:

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.

*D*Evil

Index_Set* Class::Get_Index_Set(std::size_t i) const
{
    return j_sets[i];
}

...

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 ...

Ehm...da frage ich mich gerade wie mann denn dann für statische Objekte einen Konstruktor-Aufruf vermeiden kann aber damit auch nicht die Member im destruktor nach dem function-scope nicht gelöscht werden - gäbe ja einen seg-fault.?

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?

Badestrand

Was meinst du mit statischen Objekten? Und was versprichst du dir von A o_a = A::A(dummy); ?

LordJaxom

gast_xy schrieb:

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.

Ok,

ich versuche die Erklärung nochmals:

Ich habe eine KLasse die so aussieht:

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

Index_Set::~Index_Set()

{
        if(idcs)
	      delete [] idcs;
}

Jezt würde ich aber gerne sowas machen:

void Class::function()
{
      Index_Set  is;
      //hier mache ihc was mit is z.B sowas oder was anderes

     is.function();
}

in der function() wenn die verlassen wird, wird doch automatisch der destruktor für is aufgerufen. Da is aber keinen idcs - pointer hat gibt es doch
einen seg-fault oder nicht? Schließlich passiert im default-konstruktor gar nichts, aber im "default-destruktor" wird auf idcs zugegriffen.

Meine Frage war nun: Wie könnte ich das trotzdem bewerkstelligen dass ich is so anlegen könnte wie in function(). Oder macht das so sowieso keinen Sinn?
Müsste ich dazu evtl. den default-konstuktor noch umschreiben? Dann müssten aber solche Objekte immer erst alle member initialisieren bevor man sie aufrufen kann - ist das üblich?

Danke für eure Hilfe

Badestrand

Du solltest einfach im Default-Konstruktor die/den Zeiger auch auf NULL setzen, dann wäre das gegessen
Und bei dem hier

idcs = NULL;
    len = len_a;
    idcs = new int[len];

kannst du das obere "idcs = NULL;" streichen, wird ja weiter unten sowieso mit einer "richtigen" Adresse belegt.

Edit: Und natürlich hat "is" in deinem Fall immer einen idcs-Pointer, nur der zeigt nirgendwohin. Also sollte der Wert des Zeigers NULL sein, denn darauf fragst du im Destruktor ja auch ab!

Simon2

gast_xy schrieb:

...
Jezt würde ich aber gerne sowas machen:
...
in der function() wenn die verlassen wird, wird doch automatisch der destruktor für is aufgerufen. ...

Warum ?
Ich kenne keine Situation, in der das sinnvoll wäre.
Auch ist es IMHO kein guter Stil, dem Nutzer einer Klasse (ohne dessen Wissen) ein Objekt "unter dem Hintern wegzuziehen".

Wenn is "logisch ungültig" werden soll, sollte es ein entsprechendes Flag bekommen und das entsprechend abzufragen. Eine "Statusmaschine" kann man nicht nur mittels Scopes/Konstruktor/Destruktor implementieren.

Was soll den der User nach function() noch mit is machen dürfen ?

Gruß,

Simon2.

LordJaxom

Simon2 schrieb:

Warum ?
Ich kenne keine Situation, in der das sinnvoll wäre.
Auch ist es IMHO kein guter Stil, dem Nutzer einer Klasse (ohne dessen Wissen) ein Objekt "unter dem Hintern wegzuziehen".

Ich glaube er meinte hier nichtmal Index_Set::function sondern Class::function (@gast: Mach es uns doch etwas einfacher indem Du sinnvolle Bezeichner wählst)

Zum Thema:
Wenn Deine Klasse Index_Set einen Default-Konstruktor hat, dann hat sie ihn, weil Du ihn geschrieben hast. Wenn Du in einer Klasse mit Rohspeicher hantierst, musst Du Dich auch dafür verantwortlich zeigen. Wenn in dem Konstruktor mit einem Parameter idcs initialisiert wird, und Deine einzige Sorge ist, dass das im Default-Konstruktor nicht der Fall sein könnte, initialisiere idcs einfach im Default-Konstruktor. Du hast es in der Hand! Chaka!

Simon2

LordJaxom schrieb:

Simon2 schrieb:

Warum ?
Ich kenne keine Situation, in der das sinnvoll wäre.
Auch ist es IMHO kein guter Stil, dem Nutzer einer Klasse (ohne dessen Wissen) ein Objekt "unter dem Hintern wegzuziehen".

Ich glaube er meinte hier nichtmal Index_Set::function sondern Class::function (@gast: Mach es uns doch etwas einfacher indem Du sinnvolle Bezeichner wählst)...

Ich weiß nicht, ob wir uns recht verstehen: Ich lehne eine Memberfunktion, die das zugehörige Objekt zerstört, ab.
Dafür gibt es die definierten Mechanismen mit Scopes oder new/delete und alles andere ist vom Bösen.

Gruß,

Simon2.