Dazu ein kleines Beispiel:

Ein kleines C++-Programm soll eine Klasse vereinbaren, die zwei Zahlen enthält. Die beiden Zahlen sollen von außerhalb nicht direkt manipulierbar sein, sondern nur über eine Funktion, die beide Elemente setzt sowie eine weitere Funktion, welche die Summe der beiden Elemente liefert.

In C++ könnte das so aussehen:

// Time-stamp: "(15.11.01 16:10) klasse0.cpp [Klaus Wachtler (aw38)]"
//
// kleine Demonstration einer Klasse

#include <iostream>

using namespace std;

// Vereinbarung einer Klasse:
struct ersteklasse     // statt "struct" waere genausogut
                       // "class" moeglich
{
private:               // zahl1 und zahl2 sollen nicht von ausserhalb
                       // der Klasse direkt verwendbar sein, daher private
  int     zahl1;
  int     zahl2;

public:                // Die Elementfunktionen sind von ausserhalb auf-
                       // rufbar sein, daher public

  void setzezahlen( int z1, int z2 )
  {
    zahl1 = z1;
    zahl2 = z2;
  }

  int summe( void )
  {
    return zahl1 + zahl2;
  }

};
// Hiermit ist die Klasse mit dem Namen ersteklasse vereinbart.

// Kleines Testprogramm dazu:

int main( int nargs, char *args[] )
{
  // von der Klasse ersteklasse werden zwei Instanzen a und b erzeugt:
  ersteklasse
    a,
    b;

  // a wird auf { 2, 3 } und b auf { 10, 12 } gesetzt:
  a.setzezahlen( 2, 3 );
  b.setzezahlen( 10, 12 );

    // Die Summe a.zahl1+a.zahl2 ausgeben:
  cout << "a hat den Wert " << a.summe() << "\n";
  // dto. mit b:
  cout << "b hat den Wert " << b.summe() << "\n";

  return 0;
}

Die zugehörige Programmausgabe lautet:

a hat den Wert 5
b hat den Wert 22

Dazu einige Anmerkungen:

• Die gezeigte Klasse steht für sich allein, und ist nicht von einer anderen Klasse abgeleitet.
• Eine Klassendefinition muß mit einem Semikolon (;) abgeschlossen werden.

• Da die Elemente zahl1 und zahl2 als private deklariert sind, ist von außerhalb der Klasse kein direkter Zugriff darauf möglich.

  Beispielsweise ist innerhalb der Funktion main() folgendes nicht möglich:

      // a wird auf { 2, 3 } und b auf { 10, 12 } gesetzt:
      a.zahl1 = 2;      // alles unzulaessig, weil zahl1 und
      a.zahl2 = 3;      // zahl2 in der Klasse ersteklasse
      b.zahl1 = 10;     // als private vereinbart sind!
      b.zahl2 = 12;
  
      // Die Summe a.zahl1+a.zahl2 ausgeben:
      // In dieser Form ebenfalls unzulaessig, da zahl1
      // und zahl2 private sind:
      std::cout << "a hat den Wert " << a.zahl1+a.zahl2 << "\n";
      // dto. mit b:
      std::cout << "b hat den Wert " << b.zahl1+b.zahl2 << "\n";
  

• Eine Methode bezieht sich immer auf das Objekt, über das es aufgerufen wird.

  Wenn die Funktion setzezahlen() als a.setzezahlen( 2, 3 ) aufgerufen wird, dann kann man innerhalb der Funktion mit zahl1 und zahl2 die Elemente a.zahl1 und a.zahl2 ansprechen.

• Es ist durchaus möglich, einige Datenelemente als public:, andere als private: zu deklarieren.

  Generell ist es aber besser, freien Zugriff auf die Datenelemente möglichst einzuschränken und nur über Elementfunktionen zu ermöglichen. Dies erleichtert die Fehlersuche in Programmen erheblich, da dann nur noch die Elementfunktionen als Schuldige in Frage kommen, wenn Datenelemente merkwürdige Werte annehmen. Weiterhin sind Programmänderungen wesentlich sicherer, wenn es eine klare Schnittstelle gibt.

• Wenn in einer Klasse nur Elementfunktionen als public: deklariert werden, legt man mit den Funktionen alle Operationen fest, die von außerhalb der Klasse mit den Daten möglich sind. Dies ist bei größeren Projekten oft sehr zweckmäßig.

• Die Elementfunktionen müssen nicht innerhalb der Klasse definiert werden; dort reicht auch eine Deklaration.

  Natürlich muß nichtsdestotrotz die Definition irgendwo im Programm nachgeholt werden. Dies kann man zur Aufteilung in übersichtliche Module nutzen; dazu folgt gleich ein Beispiel.

  Beispiel für eine Methodendefinition in der Klasse:

  class A
  {
  private:
    // Daten...
    int    wert;
  public:
    // Memberfunktionen:
    int holeWert()     // Die Methode wird hier gleich DEFINIERT
    {
      return wert;
    }
  };
  

  So dagegen wird die Methode nur deklariert:

  class A
  {
  private:
    // Daten...
    int    wert;
  public:
    // Memberfunktionen:
    int holeWert();    // Die Methode wird hier nur DEKLARIERT
  };
  

  In diesem Fall ist die Definition der Methode an anderer Stelle noch nötig. Dies kann prinzipiell in jedem Quelltext des Programms möglich sein; allerdings muß der Compiler an dieser Stelle die Klasse A kennen. Da es ja viele Klassen mit einer Methode namens holeWert() geben kann, ist es nötig die Funktion mit dem Klassennamen und dem scope resolution operator :: eindeutig zu zuordnen:

  // class A muß hier bekannt sein,
  // dadurch ist A::HoleWert() auch deklariert!
  
  // Memberfunktionen der Klasse A:
  int A::holeWert()     // Die Methode wird hier DEFINIERT
  {
    return wert;
  }
  

• Elementfunktionen sind manchmal sehr kurz, so daß der Funktionsaufruf teilweise mehr Rechenzeit kostet als die Funktion selbst. Dann sollte die Elementfunktion als inline (siehe Abschnitt inline-Funktionen) vereinbart werden.

• Wenn eine Elementfunktion in der Klassendeklaration nicht nur deklariert, sondern auch gleich definiert wird, dann ist sie automatisch inline