Quelltext der Seite C++/Tutorial: 12. Weitere Eigenschaften von Klassen

Nun haben wir bereits die Eigenschaften von Klassen besprochen, die am wichtigsten sind um damit ein objektorientiertes System zu modellieren, aber C++ bietet uns einige weitere Eigenschaften, die nicht unbedingt etwas mit objektorientierung zu tun haben, aber mit Klassen, eine davon sind die statischen Variablen.
==Statische Member==
===Statische Variablen===
Statische Variablen(Klassenvariablen) kennen wir bereits im Bezug auf Dateien und auf Funktionen, aber auch Klassen haben statische Variablen. Dabei haben statische Variablen mit objektorientierter Programmierung nichts zu tun.
Statische Variablen in Klassen sind vergleichbar mit globalen Variablen, sie existieren nur einmal und bleiben existent, sie befinden sich aber innerhalb einer Klasse.
Statische Variablen werden mit dem Schlüsselwort static versehen. Zudem reicht es nicht aus statische Member zu deklarieren, sie müssen ähnlich den Methoden auch noch definiert werden. Der Zugriff auf sie erfolgt mit dem Scopeoperator :: angewand auf die Klasse(innerhalb der Klasse kann auf den Scopeoperator verzichtet werden). Zudem gelten die Zugriffsmodifier auch auf statische Variablen, sodass auf eine statische Variable, die private definiert wurde nur aus Methoden dieser Klasse (ob Instanz-, oder Klassenmethoden spielt dabei keine Rolle) zugegriffen werden kann.
Was das bedeuted erklären wir an einem Beispiel einer Klasse, die zählt, wie viele Instanzen dieser Klasse existieren.
Zunächst einmal deklarieren wir eine solche Klasse, sie benötigt eine statische, private Variable, die die Anzahl der Instanzen enthält. Einen Konstruktor, der hochzählt, wenn eine Instanz erstellt wurde und einen Destruktor, der runterzählt, wenn eine Instanz zerstört wurde
<source lang="cpp">
class example 
  {
  public:
    example();
    example(example const& that);
    ~example();
  private:
    static unsigned instances;
  };
</source>
instances ist dabei die statische Variable, die genau einmal für diese Klasse existiert.
Die Konstruktoren müssen wir nun so definieren, dass die Zahl der Instanzen
<source lang="cpp">
example::example()
  {
  instances++; 
  }
example::example(example const&)
  {
  instances++;
  }
</source>
Wenn eine Instanzen zerstört wird müssen wir natürlich wieder um eins runter zählen:
<source lang="cpp">
example::~example()
  {
  instances--;
  }
</source>
Wie bereits erwähnt müssen statische Variablen ebenfalls definiert werden, das sieht dann so aus:
<source lang="cpp">
unsigned example::instances(0); //definiert die statische Variable instances und initialisiert sie mit dem Wert 0
</source>


instances beinhaltet nun immer die aktuelle Anzahl der Objekte dieser Klasse.

===Statische Methoden===
Ebenso wie statische Variablen können auch statische Methoden existieren. Um eine Methode statisch zu deklarieren wird dieser einfach static vorangestellt. Der Zugriff erfolgt wie auf statische Variablen. Schauen wir uns das auch mal an einem Beispiel an, z.B. wollen wir in unsere Klasse eine statische Methode einführen, die die Anzahl aktueller Instanzen ausgibt. In public fügen wir daher die Deklaration ein:
<source lang="cpp">
static void print_number_of_instances();
</source>
Definieren tun wir die Funktion genauso, wie eine normale Memberfunktion:
<source lang="cpp">
void example::print_number_of_instances()
  {
  cout << "Es existieren derzeit " << instances << " Instanzen" << endl;
  }
</source>

Schauen wir uns nun einmal ein Beispiel an, wie die Klasse verwendet wird:
<source lang="cpp">
int main() 
  {
  example::print_number_of_instances(); //0
  example e1;
  example e2;
    {
    example e3;
    example::print_number_of_instances(); //3
    }
  example::print_number_of_instances(); //2
  }
</source>

==Const correctness==
Eine weitere, in C++ relativ einzigartige Fähigkeit ist die Möglichkeit Klassen "const-correct" zu definieren.
Nehmen wir ein (zugegeben, relativ praxisfernes) Beispiel: eine Klasse, die einen int Member hat und eine Funktion, die einen Pointer auf diesen zurückgibt.
<source lang="cpp">
class bar 
  {
  public:
    bar(int a); //damit eine Klasse const sein kann, braucht sie einen Konstruktor
    int get_a();
  private:
    int m_a;
  };

bar::bar(int a)
  {
  m_a = a;
  }

int bar::get_a()
  {
    return m_a;
  };
</source>
Nehmen wir an, wir erstellen ein konstantes Objekt dieser Klasse:
<source lang="cpp">
int main()
  {
  bar const b;
  }
</source>
Da b nun konstant ist, ist auch m_a konstant und kann nicht verändert werden. get_a verändert diese aber nicht, also müssten wir sie doch eigentlich aufrufen können?
Geht aber nicht. Wieso?
Damit wir eine Funktion auf ein konstantes Objekt aufrufen können, müssen wir diese Funktion als const deklarieren, d.h. wir stellen dem Funktionskopf in Deklaration und Definition ein const nach:
<source lang="cpp">
    int get_a() const;
</source>
<source lang="cpp">
int bar::get_a() const
  {
    return m_a;
  };
</source>
Solche Funktionen können nun auch auf konstante Objekte aufgerufen werden. const garantiert dem Compiler, dass die Funktion die Member nicht verändert, so ist es auch nicht möglich in einer solchen Funktion eine Membervariable zu verändern. Das Objekt ist nun in der Lage const zu sein und kann dennoch korrekt verwendet werden. Wann immer ein Funktion nur lesend auf die member zugreift, sollte sie const deklariert werden, das nennt man const-correct.
===Semantische const-correctness===
Wir haben zwar bereits eine Klasse const-correct definiert, aber bisher macht dies ausschließlich einen syntaktischen Unterschied. Nehmen wir mal an, wir haben eine Funktion, get_pointer_to_a, die eben dies tut: einen Pointer auf m_a zurückgeben:
<source lang="cpp">
class bar 
  {
  public:
    bar(int a); //damit eine Klasse const sein kann, braucht sie einen Konstruktor
    int get_a() const;
    int* get_pointer_to_a();
  private:
    int m_a;
  };

int* bar::get_pointer_to_a()
  {
  return &m_a;
  }
</source>
get_pointer_to_a ist hier noch nicht als const deklariert, wir können sie also nicht auf ein konstantes Objekt aufrufen. Wollen wir sie als const deklarieren, werden wir aber feststellen, dass dies nicht so einfach geht, der GCC liefer z.B. die Fehlermeldung:
error: invalid conversion from ‘const int*’ to ‘int*’
Woran das liegt ist einfach zu verstehen. Innerhalb einer const Funktion, sind alle Member konstant. Wenn wir get_pointer_to_a also const deklarieren, ist m_a vom Typ int const m_a. Wenn wir nun einen Pointer auf diese Addresse anlegen ist dieser vom Typ int const*, unsere Funktion soll aber int* zurück geben => Fehler.
Wir müssen also unsere Funktion int const* zurückgeben lassen. Aber was wenn wir das nicht wollen? Eigentlich wollen wir, dass get_pointer_to_a auf ein normales Objekt auch einen Pointer zurückgibt, mit dem wir m_a verändern können, auf ein konstantes Objekt aber einen Pointer auf int const zurückgibt, da wir eine Konstante ja nicht verändern wollen.
Die Lösung ist simpel: wir können eine Funktion nach const überladen. Wenn wir die selbe Funktion einmal const und einmal nicht const erstellen, wird die const Version nur auf konstante Objekte der Klasse angewand, unsere Klasse sieht also folgendermaßen aus:
<source lang="cpp">
class bar 
  {
  public:
    bar(int a); //damit eine Klasse const sein kann, braucht sie einen Konstruktor
    int get_a() const; //lässt sich auf const und nicht const Objekte aufrufen und gibt m_a zurück
    int* get_pointer_to_a(); //gibt einen Pointer auf m_a zurück, wenn auf nicht konstante Objekte aufgerufen
    int const* get_pointer_to_a() const; //gibt einen Pointer auf ein nicht veränderbares m_a zurück, wenn auf konstante Objete aufgerufen
  private:
    int m_a;
  };

bar::bar(int a)
  {
  m_a = a;
  }

int* bar::get_pointer_to_a()
  {
  return &m_a;
  }
int const* bar::get_pointer_to_a() const
  {
  return &m_a;
  }

int bar::get_a() const
  {
    return m_a;
  };</source>

====mutable====
Ein weiterer Fall, der eintreten kann, ist dass wir ein konstantes Objekt haben, und in einer const Funktion trotzdem eine Variable verändern wollen. Z.B. wenn diese Variable keinerlei Einfluss auf das Verhalten des Objektes hat, sondern nur aus Geschwindigkeitsgründen existiert. Damit eine Variable auch aus const Funktionen verändert werden kann muss sie als "mutable" deklariert sein.