beim durchstöbern einiger älteren Codezeilen von mir, bin ich auf eine Parameterübergabe gestoßen, die sich C# ähnlich anmutet, mir jedoch unter C++ einiges an Kopfzerbrechen bereitet, bezüglich Stil und Speicher.

Da mir meine dazu erdachten Stichwörter leider weder bei Google noch innerhalb der Forensuche wirklich weitergeholfen haben, beschreibe ich das Problem in einem neuen Beitrag.

Folgende Situation:

class cAnyClass
{ 
// ...
public:
    cAnyClass(int i) { /* ... */ }
}

void foo(cAnyClass& o)
{
// irgendwas mit o tun
}

int main()
{
    int i = 0;
    foo(new cAnyClass(i));
    // ...
}

Nun, jenes, beim Aufruf von foo erstellte, Objekt, lebt nun bis foo ausgeführt wurde?
Soweit ich das verstanden habe wird das Objekt auf dem Heap erzeugt...? Was gibt es dazu zu sagen?

Im Grunde geht es mir darum: Sind solche Parameterübergaben eher zu vermeiden? Oder ist ein solches Design erstrebenswert? Wieso nicht, wieso doch?

Soweit,

kausa

Im übrigen geht das sowieso nicht, weil du einen Zeiger übergibst, aber die Funktion erwartet eine Referenz.

Man macht eher so etwas:

class cAnyClass
{
// ...
public:
    cAnyClass(int i) { /* ... */ }
}

void foo(cAnyClass* o) // beachte * nicht &!
{
// irgendwas mit o tun
}

int main()
{
    int i = 0;
    cAnyClass* p = new cAnyClass ( i );

    foo( p );
    // ...

    delete p; // Speicher freigeben!
}

Die Funktion erwartet ja lediglich einen Zeiger auf cAnyClass. Man kann also auch einfach einen Zeiger auf ein automatisches Objekt übergeben.

In Folge dessen also lieber einige Zeilen mehr investieren.

Edit:

Moment!

... auf ein automatisches Objekt übergeben

Was ist damit nun gemeint? Also wenn man meinen Fehler korrigiert und aus der Referenz einen Pointer zaubert, wäre meine Variante wieder in Ordnung?

Nehmen wir an, das Objekt wird nur innerhalb der Methode benötigt... wie verhält es sich dann?
Wie ist es, wenn ich das Objekt an ein anderes Objekt übergebe, müsste ich es dann von Hand löschen?

class cFirstClass
{
    // ...
}

class cSecondClass
{
 private:
    cFirstClass * fancyPointer;
 public:
    void DoWeirdThings(cFirstClass * p) { fancyPointer = p; }
 // ...
}

int main()
{
   cSecondClass obj();
   obj.DoWeirdThings(new cFirstClass(...));
}

Wo stirbt nun mein "automatisches(?)" Objekt?

Gruß,

kausa

PS: Ich hoffe es hat sich nicht wieder ein ähnlicher Fehler wie oben eingeschlichen.

beim durchstöbern einiger älteren Codezeilen von mir, bin ich auf eine Parameterübergabe gestoßen, die sich C# ähnlich anmutet, mir jedoch unter C++ einiges an Kopfzerbrechen bereitet, bezüglich Stil und Speicher.

Tipp: Programmiere nicht in C++ wie in C#. Sowas geht nach hinten los. --> Umdenken (geht nicht von heute auf morgen)

... auf ein automatisches Objekt übergeben

Was ist damit nun gemeint? Also wenn man meinen Fehler korrigiert und aus der Referenz einen Pointer zaubert, wäre meine Variante wieder in Ordnung?

Nehmen wir an, das Objekt wird nur innerhalb der Methode benötigt... wie verhält es sich dann?
Wie ist es, wenn ich das Objekt an ein anderes Objekt übergebe, müsste ich es dann von Hand löschen?

Nein. Es ist auch nicht in Ordnung.

Deine Variante kann lediglich korrekt arbeiten, wenn die Funktion selbst dann den Speicher wieder frei gibt. Dann hast du aber ein Problem, dass die Übergabe ein automatisches Objekt sein könnte, was kein delete braucht und dann hast du ein Problem.

class cAnyClass
{
// ...
public:
    cAnyClass(int i) { /* ... */ }
}

void foo(cAnyClass* o) // beachte * nicht &!
{
// irgendwas mit o tun
 delete o; // zerstöre o -> eigl. schlechtes Design!
}

int main()
{
    int i = 0;
    cAnyClass* p = new cAnyClass ( i );
    foo( p ); // ok

    cAnyClass object;
    foo ( &object ); // hups delete auf object? -> keine gute Idee

}// hier wird object korrekt zerstört