Rückgabe von Zeigern und Referenzen

Hallo zusammen,

ich habe immer das Problem, wenn ich nach einer Zeit
eine Methode aufrufe, die einen Zeiger oder eine Referenz
zurückliefert, dann weiß ich nicht mehr, ob das Objekt
für die Rückgabe erzeugt wurde oder nicht...

Woran macht ihr das bei eurem Code aus?
Wie erkennt ihr das wieder?

Gebt ihr z. B. bei bestehenden Objekten ein Object
zurück sonst ein Object& ?

Aber wie mach ich das mit Zeigern und der möglichen
Rückgabe NULL?

Gruß,
CSpille

SideWinder

Gib mal ein Beispiel, ich werd aus deinem Text nicht schlau

Gibst du nun einen Zeiger zurück dem du in der Funktion Speicher zugewiesen hast? Sowieso nicht gut. Bzw. hatte der vorher schon Speicher? Dann gibts ja gar nichts zu wissen. Worum gehts?

MfG SideWinder

class Test{
  private:
    Object o;
  public:
    Object* getObject();
}

woher weiß ich jetzt, ob ich das zurückgegebene Object zerstören muss oder nicht?

Object* Test::getObject(){
  return new Object(o);
}

// oder

Object* Test::getObject(){
  return &o;
}

Gibt es da irgendwelche Konventionen? Z. B. dass alle getter-Rückgaben nicht zerstört werden dürfen und die anderen müssen? Wie haltet ihr das?
Also, dass man es nur mit Hilfe der Header-Dateien erkennt?

Für Objekte (!=NULL) könnte man ja etwa so etwas machen:

Object Test::getObject(); // bei Objekten, die nicht zerstört werden dürfen
Object& Test::getObject(); // bei Kopien

Gibt es irgendwelche Konventionen oder handhabt ihr das?

Gruß,
CSpille

FireFlow

Alles was von einer Funktion / Methode kommt und manuell deleted werden muss is shice... Dadurch entstehen nur Leaks.

Wenn ich eine Methode habe die für den Aufrufer extra ein Objekt erzeugt, dann geht das aus dem Namen hervor (zB. createObject() ) und ob ich solche Objekte löschen muss oder nicht schlage ich in der Doku nach, manchmal übernimmt das Löschen die Klasse selber und manchmal muss man es selbst tun (QT zum Beispiel übernimmt das Löschen von Objekten sehr oft für einen, bzw. man muss es nicht löschen, wenn man nicht will).
Wenn du mit new erzeugte Objekte rausgibst (extra für den Aufrufer erzeugst) und er es löschen soll bzw. darum kümmern soll/muss, dann wäre es gut, wenn du nen smart pointer zurückgibst. Dann kann der Benutzer den für sich löschen lassen, oder es selbst tun.

Artchi

Also, normalerweise kommt es doch darauf an, wer das Objekt angelegt hat, das zurück gegeben wird. Wenn Test das Objekt intern selbst erzeugt hat, werde ich mich hüten dieses zu löschen. Das soll Test selbst machen. Wenn Test das Objekt von woanders her bekommen hat, hat der andere (der es erzeugt hat) dafür zu sorgen, das er es löscht.

Object* Test::getObject(){
  return new Object(o);
}

In dem obigen Bsp. ist ganz einfach der Methodenname falsch! Das ist keine get-Methode!!! Total falsche Bezeichnung. Wenn dann eher:

Object* Test::createObject(){
  return new Object(o);
}

// oder

Object* Test::newObject(){
  return new Object(o);
}

Am besten wäre aber, wenn man da einen std::auto_ptr zurück gibt, dann gibt es keine Missverständnisse. Irgendwo muß ja der auto_ptr mal zum Einsatz kommen. Und hier wäre er ideal. Dann muß sich niemand um die Löschung kümmern. Ein boost::shared_ptr wäre natürlich auch i.O.