Parcours
/
C++
C++
/
Exercices
/
Le jeu d'extraterrestres d'Ellen
Le jeu d'extraterrestres d'Ellen

Le jeu d'extraterrestres d'Ellen

Exercice d'apprentissage

Introduction

Les classes

Il est temps d'aborder l'un des paradigmes fondamentaux du C++ : la programmation orientée objet (POO). La POO s'articule autour des classes, des types de données définis par l'utilisateur et dotés de leur propre ensemble de fonctions associées. On commencera par les bases et on abordera des sujets plus avancés plus bas dans l'arbre du programme.

Les membres

Une classe peut avoir des variables membres et des fonctions membres. On y accède avec l'opérateur de sélection de membre .. Comme pour les variables en dehors des classes, il est conseillé d'initialiser les variables membres avec une valeur au moment de leur déclaration. Cette valeur devient alors la valeur par défaut des nouveaux objets créés à partir de cette classe.

Encapsulation et masquage des informations

Les classes offrent la possibilité de restreindre l'accès à leurs membres. Les deux access specifiers de base sont private et public. Les membres private ne sont pas accessibles depuis l'extérieur de la classe. Les membres public sont accessibles librement. Tous les membres d'une class sont private par défaut. Seuls les membres explicitement marqués public sont librement utilisables en dehors de la classe.

Un exemple simple

La définition d'une class est visible dans l'exemple suivant. Fais attention au ; après la définition :

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`
};

Tu peux accéder à toutes les variables membres depuis l'intérieur de la classe. Regarde damage à l'intérieur de la fonction cast_spell. Tu ne peux pas lire ni modifier les membres private depuis l'extérieur de la classe :

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

Les constructeurs

Les constructeurs offrent la possibilité d'affecter des valeurs aux variables membres au moment de la création de l'objet. Ils portent le même nom que la class et n'ont pas de type de retour. Une classe peut avoir plusieurs constructeurs. C'est utile si tu n'as pas toujours besoin de définir toutes les variables. Parfois, tu peux vouloir tout laisser par défaut et ne changer que la variable name. Pour un magicien important, tu peux aussi vouloir changer les dégâts, et il te faut donc deux 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

Les constructeurs sont un vaste sujet et comportent de nombreuses nuances. Si tu ne définis pas explicitement un constructor pour ta class, alors, et seulement alors, le compilateur s'en charge à ta place. C'est ce qui s'est passé dans le premier exemple ci-dessus. L'objet silverhand est créé en appelant le constructeur par défaut, aucun argument n'a été passé. Toutes les variables reçoivent la valeur indiquée dans la définition de la classe. Si tu n'avais donné aucune valeur dans cette définition, les variables pourraient ne pas être initialisées, ce qui pourrait avoir des conséquences inattendues.

Note

Les struct

Les struct viennent des racines C du langage et sont aussi anciennes que le C++ lui-même. Ce sont en pratique la même chose que les classes, à une exception importante près. Par défaut, tout ce qui se trouve dans une class est private. Les struct, elles, sont public tant qu'on ne précise pas le contraire. Par convention, le mot-clé struct est souvent utilisé pour des structures de données uniquement. On préfère le mot-clé class pour les objets qui doivent garantir certaines propriétés. Un tel invariant pourrait être que le damage de ta class Wizard ne puisse pas devenir négatif. La variable damage est privée et toute fonction qui modifie les dégâts garantirait que l'invariant est préservé.

Instructions

Ellen crée un jeu dans lequel le joueur doit combattre des extraterrestres. Elle vient tout juste de découvrir la programmation orientée objet (POO) et elle est impatiente de tirer parti de ce que l'usage de classes pourrait apporter à son programme.

Pour le plus grand plaisir d'Ellen, tu as proposé ton aide et elle t'a confié la tâche de programmer les extraterrestres que le joueur doit combattre.

1. Crée la classe Alien

Définis la classe Alien avec un constructeur qui accepte deux paramètres int x et y et les range dans les variables membres x_coordinate et y_coordinate. Chaque extraterrestre démarre également avec un niveau de santé de 3, donc la variable membre health doit aussi être initialisée.

health doit être une variable membre privée. Pour permettre aux autres parties du programme de lire les informations sur la santé, Ellen veut une méthode public get_health() qui renvoie un int.

Alien alien{2, 0};
alien.x_coordinate;
// => 2
alien.y_coordinate;
// => 0
alien.get_health();
// => 3

Ainsi, chaque extraterrestre doit pouvoir suivre en interne sa propre position et sa santé.

2. La fonction hit

Ellen aimerait que la class Alien ait une méthode hit qui diminue de 1 la santé d'un objet extraterrestre lorsqu'elle est appelée. Ainsi, elle peut simplement appeler some_alien_instance.hit() au lieu de devoir modifier manuellement la santé d'un extraterrestre. Vérifie que les points de vie ne descendent pas en dessous de zéro. La fonction doit renvoyer true. Ellen veut introduire des boucliers plus tard, qui signaleraient alors false si le bouclier est levé.

Alien alien {0, 0};
alien.get_health();
// => 3 (Initial health value)

alien.hit(); // Decrements health by 1 point.
alien.get_health();
// => 2

3. La fonction is_alive

Tu réalises que si la santé continue de baisser, elle finira probablement par atteindre 0. Ce serait une bonne idée d'ajouter une méthode is_alive qu'Ellen peut appeler rapidement pour vérifier si l'extraterrestre est... eh bien... en vie. 😉 some_alien_instance.is_alive() doit renvoyer un booléen.

alien.get_health();
// => 1
alien.is_alive();
// => true
alien.hit();
alien.get_health();
// => 0
alien.is_alive();
// => false

4. La fonction teleport

Dans le jeu d'Ellen, les extraterrestres peuvent se téléporter ! Tu devras écrire une méthode teleport qui prend les valeurs x_new et y_new et modifie les coordonnées de l'extraterrestre en conséquence. Pour l'instant, la fonction doit renvoyer true. Ellen veut ajouter des bombes qui bloquent la téléportation dans les niveaux suivants, qui signaleraient alors false pour les tentatives de téléportation ratées.

alien.teleport(5, -4);
alien.x_coordinate;
// => 5
alien.y_coordinate;
// => -4

5. La fonction collision_detection

Si les extraterrestres peuvent être touchés par quelque chose, ils doivent alors pouvoir détecter quand une telle collision risque de se produire. Ellen a besoin de savoir si deux extraterrestres occupent les mêmes coordonnées. La fonction collision_detection() prend un autre objet extraterrestre en argument et renvoie un bool.

Alien lrrr {3, 6};
Alien ndnd {-2, 12};
lrrr.collision_detection(ndnd);
// => false
ndnd.teleport(3, 6);
ndnd.collision_detection(lrrr);
// => true
Modifie via GitHub Le lien s'ouvre dans une nouvelle fenêtre ou un nouvel onglet
C++ Exercism

Prêt à commencer Le jeu d'extraterrestres d'Ellen ?

Inscris-toi sur Exercism pour apprendre et maîtriser C++ avec 19 concepts100 exercices, et un vrai mentorat humain, le tout gratuitement.