OOP: Objekte als Membervariablen

Hallo,

ich habe ein Projekt, in dem Teilmengenbeziehungen von Objekten vorkommen, so in der Art wie im Codebeispiel, aber durchaus über noch mehrere Ebenen.

Ich frage mich jetzt: Gibt es irgendwelche Richtlinien, ob man hier z.B nur den Zeiger auf object1 speichern sollte und welche Signaturen die getter und setter haben sollten. Also sollten die Zeiger oder Referenzen zurückliefern/bekommen usw.

Ich finde bisher nur Beispiele/Diskussionen, wo nur primitive Datentypen als Member vorkommen oder es dann um die Verwendung von gettern/settern an sich geht. Es geht mir aber um den Speicherplatzverbrauch und Geschwindigkeit, denn es kann ja nicht sinnvoll sein, wenn ich hinreichend komplexe Objekte ständig hin und her kopiere.

class Object1 {
  ...
}

class Object2 { 
private:
  Object1 object1;
public: 
  ...
  void setObject1(Object1 object1);
  Object1 getObject1();
};

thordk

deine beispielklasse arbeitet mit kopien der objekte, was grundsätzlich auf die performance gehen kann.

so als faustregel sind referenzen, oder noch besser: const referenzen, vorzuziehen, sofern sie möglich sind.

Simon2

Hi,

frageEuch schrieb:

...Teilmengenbeziehungen von Objekten ...

Das muß (im Rahmen der fachlichen Klärung) exakter spezifiziert werden - besonders, was die "Eigentumsverhältnisse", die "Lebenszyklen" der Objekte angeht und ob die Beziehungen wechseln können, ....

Ich würde als Faustregel eher sagen:

A Hat das "innere Objekt" keinerlei "Leben" außerhalb, sollte es dem äußeren gehören und von ihm erzeugt werden (entweder auf Stack oder Heap).
A & sollte das äußere länger leben als das Innere => Zeiger; sonst => Stack
B Hat das innere ein "Eigenes Leben", sollte man es dem äußeren Objekt entsprechend von Außen (via Referenz oder Zeiger) übergeben können.
B & Ist das Äußere seine ganze Lebenszeit an das innere gebunden => Referenz im Konstruktor

Kann man noch feiner granularisieren, aber ich muß jetzt weg.

Gruß,

Simon2.

Ok, danke euch. Das mit den Lebensdauern werd ich mir noch mal genau überlegen. Erst mal benutze ich dann:

class Object1 {
  ...
}

class Object2 { 
private:
  Object1 object1;
public: 
  ...
  void setObject1(Object1 &object1);
  Object1& getObject1();
};

Simon2

frageEuch schrieb:

Ok, danke euch. Das mit den Lebensdauern werd ich mir noch mal genau überlegen. Erst mal benutze ich dann:
class Object1 {
  ...
}

class Object2 { 
private:
  Object1 object1;
public: 
  ...
  void setObject1(Object1 &object1);
  Object1& getObject1();
};

vorab ein kleiner Tipp: die cpp-Flags sind noch ein wenig einfacher zu lesen...

Dann ein zweiter kleiner Tipp ("const as const can"):

...
class Object2 { 
...
public: 
...
  void setObject1(Object1 const & object1); // Du willst doch nicht das übergebene Objekt1 verändern, oder ?

// Folgendes KÖNNTE passen: 
// 1. const-Referenz zurückgeben: 
// - Damit schützt Du Deine Kapselung vom object1.
// - Wenn Du das nicht willst, musst Du Dir überlegen, ob Du Objekt1 nicht direkt public machen möchtest 
//    (MUSS man dann nicht, könnte aber einfacher sein)
// 2. const-Funktion:
// - Wenn getObject1() das Objekt2 nicht ändert, kann man sie auch für konstante Objekt2s aufrufen
  Object1 const & getObject1() const;
};

Wie gesagt: Musst schauen, ob das passt. (eben "... as can")

Gruß,

Simon2.