Kuhlins: Objektorientiertes Design für C++

4.6   Spezielle Eigenschaften von Klassen

Es gibt keine Elementfunktion, die generell für jede Klasse sinnvoll ist. Als spezielle Objekteigenschaften sind denkbar:

• Objekte sollen nicht kopiert werden.

  Der Copy-Konstruktor und der Zuweisungsoperator sind private zu deklarieren, ohne eine Definition anzugeben (Meyers 1991).

  class Depot {
  public:
     // ...
  private:
     // Schnittstelle ohne Kopierfunktionen
     Depot(const Depot&);
     Depot& operator=(const Depot&);
     // ...
  };
  

• Objekte sollen ausschließlich auf dem Heap gespeichert werden.

  Die Konstruktoren werden nicht public deklariert. Objekte können - abgesehen von Elementfunktionen und friends - nur mittels public bereitgestellter static Elementfunktionen kreiert werden, die jeweils einen Zeiger auf ein mit new auf dem Heap angelegtes Objekt zurückgeben (ARM §12.2c und FAQ 311).

  class X {
  public:
     static X* newX() { return new X; }
     // ...
  private:
     X();  // Schnittstelle ohne public Konstruktor
     // ...
  };
  
  void test() {
     X* x = X::newX();
     // ...
     delete x;
  }
  

  Der gleiche Effekt läßt sich auch erzielen, indem der Destruktor private deklariert wird (ARM §12.2c und Taligent 1994). Zum Löschen solcher Objekte, die ausschließlich mit new kreiert werden können, kann eine public Elementfunktion bereitgestellt werden.

  class X {
  public:
     void deleteX() { delete this; }
     // ...
  private:
     ~X();  // Schnittstelle ohne public Destruktor
  };
  
  void test() {
     X* x = new X;
     // ...
     x->deleteX();
  }
  

Darüber hinaus sind noch weitere spezielle Eigenschaften möglich:

• Objekte sollen nicht auf dem Heap gespeichert werden.

  Der operator new ist private zu deklarieren (Taligent 1994). Dann sollte auch operator delete im private Teil stehen (Meyers 1996).

• Es soll nur genau ein Objekt der Klasse geben.

  Die Konstruktoren werden private deklariert. Eine friend-Funktion legt ein static Objekt an und liefert bei jedem Aufruf eine Referenz auf dieses Objekt (vgl. Meyers 1996).

  class X {
  public:
     friend X& gibX();
     void f() { /* Beispiel fuer eine Elementfunktion */ }
     // ...
  private:
     X();  // Schnittstelle ohne public Konstruktoren
     X(const X&);
     // ...
  };
  
  X& gibX() {
     static X x;
     return x;
  }
  
  void test() {
     gibX().f();
  }
  

  Einen ähnlichen Ansatz schlagen Gamma et al. (1995) unter dem Namen "Singleton" vor.

  Ein weiterer Spezialfall sind Klassen, von denen keine anderen Klassen abgeleitet werden sollen. Sie werden Blattklassen ("Leaf-class") genannt (FAQ 433, Rumbaugh und Booch 1995). Da solche Klassen nicht als Basisklassen fungieren, werden für sie keine virtuellen Elementfunktionen und keine protected Elemente definiert.