Hier folgt eine weitere Form, die durch C++-Objekte dargestellt werden kann: Variablen eines anwenderdefinierten Datentyps. Wir werden Objekte verwenden, um Längenangaben darzustellen, deren Maße dem Englischen Maßsystem entsprechen. ES folgt das Listing von ENGLOBJ:

// englobj.cpp
// Objekte bei Verwendung englischer Maßeinheiten
#include <iostream.h>

class Distance  // Klasse für Englisches Maßsystem
 {
  private:
   int feet;
   float inches;
  public:
   void setdist(int ft,float in)  // Längenangaben auf Werte der Argumente setzen
    { feet = ft; inches = in; }
   void getdist()  // Länge vom Anwender einlesen
    {
     cout << "\nGeben Sie Feet ein: "; cin >> feet;
     cout << "Geben Sie Inch ein: "; cin >> inches;
    }
   void showdist()  // Längenangabe anzeigen
    { cout << feet << "\'-" << inches << '\"'; }
 };

void main()
 {
  Distance dist1,dist2;  // Zwei Längenangaben definieren
  dist1.setdist(11,6.65);  // dist1 setzen
  dist2.getdist();  // dist2 vom Amwender einlesen
       // Längen anzeigen
  cout << "\ndist1 = "; dist1.showdist();
  cout << "\ndist2 = "; dist2.showdist();  
 }

Es folgt ein Beispieldialog mit dem Programm:

Geben Sie Feet ein: 10
Geben Sie Inch ein: 4.75

dist1 = 11'-6.25" Bereitgestelt durch Argumente dist2 = 10'-4.75" Eingabe des Anwenders

Konstruktoren

Das Beispiel ENGLOBJ zeigt zwei Wege auf, um die Datenelemente in einem Objekt mit Werten zu versehen. Manchmal ist es vorteilhaft, wenn ein Objekt sich nach seiner Erstellung selbst initialisieren kann, ohne daß ein gesonderter Aufruf einer Komponentenfunktion erforderlich wäre. Die automatische Initialiesierung wird unter Verwendung einer besonderen Komponentenfunktion durchgeführt, die als Konstruktor bezeichnet wird. Ein Konstuktor ist eine Komponentenfunktion, die immer automatisch ausgeführt wird, wenn ein Objekt erstellt wird.

Ein Zählerbeispiel

Als ein Beispiel werden wir eine Klasse von Objekten erstellen, die als vielseitig einsetzbares Programmierelement nützlich sein kann.

Lassen Sie uns davon ausgehen, daß der Zähler im folgenden Programm eine wichtige Rolle spielt und daß viele verschiedene Funktionen auf ihm zugreifen müssen. In der Prozedualsprache wie C würde ein Zähler wahrscheinlich als externe Variable implementiert werden. Wie wir bereits angemerkt haben, können externe Variablen aber ungewollt verändert werden. Dieses Beispiel mit dem Namen COUNTER enthält eine Zählervariable, die durch ihre Komponentenfunktionen verändert werden kann.

// counter.cpp
// Objekt als Darstellungsform für eine Zählervariable
#include <iostream.h>

class Counter
 {
  private:
    unsigned int count;  // Zähler
  public:
    Counter() { count = 0; }  // Konstruktor
    void inc_count() { count++; }  // Zähler inkrementieren
    void get_count() { return count; } Rückgabe des Zählerwerts
 };

void main()
 {
  Counter c1,c2;  // Definieren und initialisieren
  cout << "\nc1=" << c1.get_count();  // Anzeigen
  cout << "\nc2=" << c2.get_count();
  c1.inc_count();  // c1 inkrementieren
  c2.inc_count();  // c2 inkrementieren
  cout << "\nc1=" << c1.get_count();  // Erneut anzeigen
  cout << "\nc2=" << c2.get_count();
 }

c1=0
c2=0
c1=1
c2=1

Destruktoren

Wir haben gesehen, daß eine besondere Komponentenfunktion - der Konstruktor - automatisch aufgerufen wird, wenn ein Objekt erstmals erstellt wird. Sie haben villeicht schon vermutet, daß eine weitere Funktion automatisch aufgerufen wird, wenn ein Objekt eliminiert wird. Das ist tatsächlich der Fall. Solch eine Funktion wird als Destruktor bezeichnet. Ein Destruktor hat denselben Namen wie ein Konstruktor (welcher mit dem Klassennamen identisch ist), mit dem Unterschied, daß ihm eine Tilde vorangestellt wird:

class Foo
 {
  private:
    int data;
  public:
    Foo() { data = 0; }  // Konstuktor (derselbe Name wie die Klasse)
    ~Foo() { }  // Destruktor (derselbe Name mit Tilde)
 }

Die gebräuchlichste Einsatzweise von Destrucktoren besteht darin, den vom Konstruktor für das Objekt bestimmten Speicherplatz wieder freizugeben.

36