Tracks
/
C++
C++
/
Übungen
/
Ellens Alien-Spiel
Ellens Alien-Spiel

Ellens Alien-Spiel

Lernübung

Einführung

Klassen

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.

Member

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.

Kapselung und Informationsverbergung

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.

Ein einfaches Beispiel

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

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.

Note

Structs

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.

Anleitung

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.

1. Erstelle die Alien-Klasse

Definiere 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.

2. Die hit-Funktion

Ellen 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

3. Die is_alive-Funktion

Du 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

4. Die teleport-Funktion

In 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

5. Die collision_detection-Funktion

Wenn 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
Über GitHub bearbeiten Der Link öffnet sich in einem neuen Fenster oder Tab
C++ Exercism

Bereit, mit Ellens Alien-Spiel zu starten?

Melde dich bei Exercism an, um C++ mit 19 Konzepte100 Übungen und echtem menschlichen Mentoring zu lernen und zu meistern, alles kostenlos.