ich benutze eine Funktion (die nicht von mir geschrieben ist), welche ein Objekt erstellt und es zurück gibt. Ich möchte dieses Objekt an einen Zeiger übergeben, also diesen auf das Objekt zeigen lassen.

ich dachte es wäre so möglich:

X* x = &createX();

quasi die Adresse des Rückgabewertes der Funktion an den Pointer übergeben. Funktioniert aber nicht.

Aber wie geht es sonst???

Danke für die Hilfe!

Grüße

X x = CreateX();

du kannst aber auch den hier probieren

X& x = CreateX();

wahrscheinlich brauchst du letzteres.

geht das überhaupt?

X* createX()
{
    X* bla = new X();
    return bla;
}

..

X* x = createX();
...
delete x;

?

edit: Allerdings ist es etwas unsauber, da der Benutzer von Funktionen nichts mit deren Speicherverwaltung zu tun haben sollte. Als sauberere Lösung könntest du eine Funktion deleteX schreiben, die das Objekt wieder löscht, oder besser den std::auto_ptr benutzen (oder einer der boost-smart-Pointer, hab zufällig vor 5 Minuten einen verdammt guten Artikel dazu gelesen)

Mit den Boost-Smart-Pointern hab ich's noch nicht so raus (kannst du dir aber leicht aus dem Artikel erarbeiten), mit dem auto_ptr würde es so aussehen:

#include <memory>
#using namespace std;

auto_ptr<X> createX()
{
    auto_ptr<X> x( new X() );
    ..
    return x;
}

..

auto_ptr<X> x = createX();
// Hier musst du x nämlich nicht mehr freigeben, wird nach dem Verlassen des Scopes vernichtet

X& x = CreateX();

Das is kein legales C++ nicht.
(MSVC mit "Microsoft Extensions=on" frisst es nur trotzdem)
Du kannst ne non-const Referenz nicht an ne rvalue binden.
(Mit "X const&" wäre es OK)

Du kannst ne non-const Referenz nicht an ne rvalue binden.
(Mit "X const&" wäre es OK)

Wäre das dann eigentlich das gleiche wie "const X&"? Ich hab das mit den verschiedenen const-Dingern noch nie verstanden

hustbaer schrieb:

Du kannst ne non-const Referenz nicht an ne rvalue binden.
(Mit "X const&" wäre es OK)

Wäre das dann eigentlich das gleiche wie "const X&"? Ich hab das mit den verschiedenen const-Dingern noch nie verstanden

Ja, wäre es. Das 'const' ist eigentlich ganz einfach. Es kann halt sowohl vor als auch nach dem Typennamen stehen und bindet vorzugsweise nach links. Wenn man sich an die Konvention hält, es nur rechts ranzuschreiben, dann geht es sogar noch einfacher:

T const * const * const * …

… kann man beliebig weiterführen. Ein gegebenes 'const' bezieht sich immer auf den linksstehenden Teilausdruck.

Jo, warum nicht

X* createX()
{
    X* bla = new X();
    return bla;
}

..

X* x = createX();
...
delete x;

?

edit: Allerdings ist es etwas unsauber, da der Benutzer von Funktionen nichts mit deren Speicherverwaltung zu tun haben sollte. Als sauberere Lösung könntest du eine Funktion deleteX schreiben, die das Objekt wieder löscht, oder besser den std::auto_ptr benutzen (oder einer der boost-smart-Pointer, hab zufällig vor 5 Minuten einen verdammt guten Artikel dazu gelesen)

Mit den Boost-Smart-Pointern hab ich's noch nicht so raus (kannst du dir aber leicht aus dem Artikel erarbeiten), mit dem auto_ptr würde es so aussehen:

#include <memory>
#using namespace std;

auto_ptr<X> createX()
{
    auto_ptr<X> x( new X() );
    ..
    return x;
}

..

auto_ptr<X> x = createX();
// Hier musst du x nämlich nicht mehr freigeben, wird nach dem Verlassen des Scopes vernichtet

natürlich könnte das so funktionieren, aber die Funktion createX ist nicht von mir geschrieben, daher kann ich die nicht so verändern. Gibt es denn keine Möglichkeit einfach nur die Adresse des Rückgabewertes einem Pointer zu überreichen??

danke

wenn ich es anständig zuweise, dann verliere ich das objekt nacht dem verlassen des scopes. mir geht es darum das zu verhindern, ohne eine kopie erstellen zu müssen.

Wenn du die Funktion nicht beeinflussen kannst, geht das nicht.

Ergo: du mußt dir die Rückgabe in eine eigene Variable kopieren, um sie weiter verwenden zu können:

X x = createX();
//oder - wenn du unbedingt Zeiger brauchst:
X* x = new X(createX());

(wenn die Funktion selber einen Zeiger/Referenz zurückgibt, hast du gute Chancen, daß das dahinterliegende Objekt noch etwas überlebt (außer der Autor hat Mist gebaut und eine Referenz auf eine lokale Variable geliefert) - und dann ist es auch legal, deren Adresse zu bestimmen)

hmm ... das ist ja doof.
Also muss ich das Objekt normal rausholen, Speicher allokieren und eine Kopie in den Speicher schreiben? (und die Kopie geht verloren).

Aber das ist ja schlussendlich voll die Performance-Verschwendung, als wenn ich einfach irgendwie auf das bereits erstellte Objekt zeigen könnte und gut ist.

Aber das ist ja schlussendlich voll die Performance-Verschwendung, als wenn ich einfach irgendwie auf das bereits erstellte Objekt zeigen könnte und gut ist.

Vermutlich - aber darüber solltest du dich bei dem *** beschweren, der die createX()-Funktion geschrieben hat.

Klingt logisch, ist aber irgendwie schade, aus den bereits erwähnten Gründen meines letzten Posts.

Danke an alle für die Hilfe!!

anchelito schrieb:

Aber das ist ja schlussendlich voll die Performance-Verschwendung, als wenn ich einfach irgendwie auf das bereits erstellte Objekt zeigen könnte und gut ist.

Vermutlich - aber darüber solltest du dich bei dem *** beschweren, der die createX()-Funktion geschrieben hat.

Aber ihr liefert doch auch nicht immer einen Zeiger zurück bei ner Funktion oder doch?