Klassen in C++

Wie in Java beschreibt eine Klasse, welche Attribute und Methoden ihre Objekte haben — in C++ steht alles in einem class-Block.

#include <iostream>
using namespace std;

class Akku {
private:
    int ladung;                  // Attribut: 0 … 100 Prozent
public:
    Akku(int start) {            // Konstruktor: Name der Klasse, kein Rückgabetyp
        ladung = start;
    }
    void laden(int prozent) {    // Methode
        ladung = ladung + prozent;
        if (ladung > 100) ladung = 100;
    }
    int getLadung() {            // Getter: nur lesen
        return ladung;
    }
};                               // Semikolon nicht vergessen!

int main() {
    Akku a(80);                  // Objekt anlegen – ohne new
    a.laden(30);                 // Methode aufrufen
    cout << "Ladung: " << a.getLadung() << " %" << endl;
    return 0;
}

$ g++ akku.cpp -o akku
$ ./akku
Ladung: 100 %

• class:class Akku { … }; — der Block endet mit Semikolon.
• private:nur Methoden der Klasse dürfen zugreifen (Kapselung).
• public:von außen nutzbar: Konstruktor und Methoden.
• Konstruktor:heißt wie die Klasse, hat keinen Rückgabetyp, setzt die Startwerte.
• Objekt:Akku a(80); legt das Objekt an und ruft den Konstruktor auf.
• Methodenaufruf:a.laden(30); — Objekt, Punkt, Methode.
• Getter:getLadung() gibt den Wert heraus, ohne ihn änderbar zu machen.
• Kapselung:a.ladung = 500; → error: 'int Akku::ladung' is private within this context.

Baue die Klasse Akku aus Bausteinen: ziehe jeden Baustein in private, public oder ans Klassenende — oder tippe ihn an und dann den Bereich. Mit der Tastatur: Baustein fokussieren, Pfeiltasten verschieben ihn von Bereich zu Bereich. Vorsicht, drei Bausteine sind fehlerhaft. Dann Übersetzen und testen.

class Akku {

Halte fest: Das Attribut gehört nach private, Konstruktor und Methoden nach public — nur dann bleibt die Ladung zwischen 0 und 100 %. Der Compiler meldet Syntaxfehler (fehlendes ;, Rückgabetyp beim Konstruktor) und Zugriffe auf private Teile; ein öffentliches Attribut übersetzt er dagegen klaglos.

Größere Klassen teilt man wie Funktionen in C auf: Bauplan in den Header, Methodenrümpfe in eine eigene Datei.

#ifndef AKKU_H
#define AKKU_H

class Akku {
private:
    int ladung;
public:
    Akku(int start);             // nur Prototypen
    void laden(int prozent);
    void entladen(int prozent);
    int getLadung();
};

#endif

#include "akku.h"

Akku::Akku(int start) : ladung(start) {   // Initialisierungsliste
}

void Akku::laden(int prozent) {
    ladung = ladung + prozent;
    if (ladung > 100) ladung = 100;
}

void Akku::entladen(int prozent) {
    ladung = ladung - prozent;
    if (ladung < 0) ladung = 0;
}

int Akku::getLadung() {
    return ladung;
}

#include <iostream>
#include "akku.h"
using namespace std;

int main() {
    Akku handy(35);
    handy.entladen(50);
    cout << "Handy: " << handy.getLadung() << " %" << endl;
    return 0;
}

$ g++ main.cpp akku.cpp -o akku
$ ./akku
Handy: 0 %

• Klasse::methode:void Akku::laden(int prozent) — der Bereichsoperator :: sagt, zu welcher Klasse die Methode gehört.
• Header:akku.h enthält nur die Klasse mit Prototypen, geschützt durch den Include-Guard.
• Initialisierungsliste:: ladung(start) setzt das Attribut, bevor der Rumpf läuft — kurz für ladung = start;.
• Übersetzen:alle .cpp-Dateien angeben: g++ main.cpp akku.cpp -o akku.
• struct:wie class, nur ist alles automatisch public.
• Vergleich Java:Java: Akku a = new Akku(80); — C++: Akku a(80);; das Objekt wird am Ende von main automatisch aufgeräumt.

struct Punkt {                   // struct: alles automatisch public
    int x;
    int y;
};

Punkt p;
p.x = 3;                         // erlaubt, weil public