Es ist Zeit für eines der Kernparadigmen von C++: die objektorientierte Programmierung (OOP).
Bei der OOP dreht sich alles um classes, also benutzerdefinierte Datentypen mit ihren eigenen zugehörigen Funktionen.
Wir fangen mit den Grundlagen an und behandeln weiter unten im Lehrplan fortgeschrittenere Themen.
Klassen können Membervariablen und Memberfunktionen haben.
Zugriff darauf bekommst du über den Operator . für die Memberauswahl.
Wie bei Variablen außerhalb von classes ist es ratsam, Membervariablen bei der Deklaration mit einem Wert zu initialisieren.
Dieser Wert wird dann zum Standard für neu erzeugte Objekte dieser Klasse.
Klassen bieten die Möglichkeit, den Zugriff auf ihre Member einzuschränken.
Die beiden grundlegenden access specifiers sind private und public.
Auf private-Member kann von außerhalb der Klasse nicht zugegriffen werden.
Auf public-Member kannst du frei zugreifen.
Alle Member einer class sind standardmäßig private.
Nur Member, die ausdrücklich als public markiert sind, lassen sich außerhalb der Klasse frei verwenden.
Die Definition einer class siehst du im folgenden Beispiel.
Achte auf das ; nach der Definition:
class Wizard {
public: // from here on all members are publicly accessible
int cast_spell() { // defines the public member function cast_spell
return damage;
}
std::string name{}; // defines the public member variable `name`
private: // from here on all members are private
int damage{5}; // defines the private member variable `damage`
};
Innerhalb der Klasse kannst du auf alle Membervariablen zugreifen.
Schau dir damage in der Funktion cast_spell an.
private-Member kannst du von außerhalb der Klasse weder lesen noch ändern:
Wizard silverhand{};
// calling the `cast_spell` function is okay, it is public:
silverhand.cast_spell();
// => 5
// name is public and can be changed:
silverhand.name = "Laeral";
// damage is private:
silverhand.damage = 500;
// => Compilation error
Konstruktoren ermöglichen es, Membervariablen bei der Erzeugung eines Objekts Werte zuzuweisen.
Sie haben denselben Namen wie die class und keinen Rückgabetyp.
Eine Klasse kann mehrere Konstruktoren haben.
Das ist praktisch, wenn du nicht immer alle Variablen setzen musst.
Manchmal möchtest du alles bei den Standardwerten lassen und nur die Variable name ändern.
Bei einem mächtigen Wizard möchtest du vielleicht auch den Schaden ändern, also brauchst du zwei constructors.
class Wizard {
public:
Wizard(std::string new_name) {
name = new_name;
}
Wizard(std::string new_name, int new_damage) {
name = new_name;
damage = new_damage;
}
int cast_spell() {
return damage;
}
std::string name{};
private:
int damage{5};
};
Wizard el{"Eleven"}; // deals 5 damage
Wizard vecna{"Vecna", 50}; // deals 50 damage
Konstruktoren sind ein großes Thema mit vielen Feinheiten.
Wenn du keinen constructor für deine class ausdrücklich definierst, dann, und nur dann, erledigt der Compiler die Arbeit für dich.
Genau das ist im ersten Beispiel oben passiert.
Das Objekt silverhand wird durch den Aufruf des Standardkonstruktors erzeugt, es wurden keine Argumente übergeben.
Alle Variablen werden auf den Wert gesetzt, der in der Definition der Klasse angegeben wurde.
Hättest du in dieser Definition keine Werte angegeben, könnten die Variablen uninitialisiert sein, was unerwünschte Folgen haben kann.
Structs stammen aus den ursprünglichen C-Wurzeln der Sprache und sind so alt wie C++ selbst.
Sie sind praktisch dasselbe wie classes, mit einer wichtigen Ausnahme.
Standardmäßig ist in einer class alles private.
Bei Structs hingegen ist alles public, solange nichts anderes definiert ist.
Üblicherweise wird das Schlüsselwort struct oft für reine Datenstrukturen verwendet.
Das Schlüsselwort class bevorzugt man für Objekte, die bestimmte Eigenschaften sicherstellen müssen.
Eine solche Invariante könnte sein, dass der damage deiner Wizard-class nicht negativ werden kann.
Die Variable damage ist privat, und jede Funktion, die den Schaden ändert, würde dafür sorgen, dass die Invariante erhalten bleibt.
Ellen entwickelt ein Spiel, in dem man gegen Aliens kämpfen muss.
Sie hat gerade etwas über objektorientierte Programmierung (OOP) gelernt und möchte unbedingt nutzen, was ihr der Einsatz von classes für ihr Programm bieten kann.
Zu Ellens Freude hast du angeboten zu helfen, und sie hat dir die Aufgabe übertragen, die Aliens zu programmieren, gegen die man kämpfen muss.
Alien-KlasseDefiniere die Alien-Klasse mit einem Konstruktor, der zwei int-Parameter x und y entgegennimmt und sie in den Membervariablen x_coordinate und y_coordinate ablegt.
Jeder Alien startet außerdem mit einem Gesundheitswert von 3, also sollte auch die Membervariable health initialisiert werden.
health sollte eine private Membervariable sein.
Damit andere Teile des Programms die Gesundheitsinformationen lesen können, möchte Ellen eine public-Methode get_health() haben, die einen int zurückgibt.
Alien alien{2, 0};
alien.x_coordinate;
// => 2
alien.y_coordinate;
// => 0
alien.get_health();
// => 3
Jetzt soll jeder Alien seine eigene Position und Gesundheit intern verwalten können.
hit-FunktionEllen möchte, dass die class-Klasse eine hit-Methode hat, die beim Aufruf die Gesundheit eines Alien-Objekts um 1 verringert.
So kann sie einfach some_alien_instance.hit() aufrufen, statt die Gesundheit eines Aliens manuell ändern zu müssen.
Stell sicher, dass die Gesundheitspunkte nicht unter null fallen.
Die Funktion sollte true zurückgeben.
Ellen möchte später Schilde einführen, die dann false melden würden, wenn der Schild aktiv ist.
Alien alien {0, 0};
alien.get_health();
// => 3 (Initial health value)
alien.hit(); // Decrements health by 1 point.
alien.get_health();
// => 2
is_alive-FunktionDu merkst, dass die Gesundheit irgendwann wahrscheinlich 0 erreichen wird, wenn sie weiter sinkt.
Es wäre eine gute Idee, eine is_alive-Methode hinzuzufügen, die Ellen schnell aufrufen kann, um zu prüfen, ob der Alien ... nun ja ... noch lebt. 😉
some_alien_instance.is_alive() sollte einen booleschen Wert zurückgeben.
alien.get_health();
// => 1
alien.is_alive();
// => true
alien.hit();
alien.get_health();
// => 0
alien.is_alive();
// => false
teleport-FunktionIn Ellens Spiel können sich die Aliens teleportieren!
Du musst eine teleport-Methode schreiben, die die Werte x_new und y_new entgegennimmt und die Koordinaten des Aliens entsprechend ändert.
Vorerst sollte die Funktion true zurückgeben.
Ellen möchte in späteren Leveln Bomben hinzufügen, die das Teleportieren blockieren und dann false für fehlgeschlagene Teleportversuche melden würden.
alien.teleport(5, -4);
alien.x_coordinate;
// => 5
alien.y_coordinate;
// => -4
collision_detection-FunktionWenn die Aliens von etwas getroffen werden können, müssen sie erkennen können, wann eine solche Kollision auftreten könnte.
Ellen muss wissen, ob zwei Aliens dieselben Koordinaten belegen.
Die collision_detection()-Funktion nimmt ein weiteres Alien-Objekt als Argument entgegen und gibt einen bool zurück.
Alien lrrr {3, 6};
Alien ndnd {-2, 12};
lrrr.collision_detection(ndnd);
// => false
ndnd.teleport(3, 6);
ndnd.collision_detection(lrrr);
// => true
Melde dich bei Exercism an, um C++ mit 19 Konzepte100 Übungen und echtem menschlichen Mentoring zu lernen und zu meistern, alles kostenlos.