Première classe

C’est parti pour la pratique ! Vous allez ici apprendre à définir une classe en C++ et à l’instancier.

Méthodologie

Téléchargez et ouvrez le fichier 2-first-class.cpp, dans lequel on vous fournit le code de la fonction main.

int main()
{
    // Person p;

    // p.set_name("Batman");
    // p.set_age(23);

    // std::cout << "Person named '" << p.get_name() << "' is " << p.get_age() << " years old." << std::endl;

    return 0;
}

Vous allez procéder ici en suivant plus ou moins la méthodologie Test Driven Development (ou TDD), qui consiste à écrire le code des tests avant d’écrire le code appelé. Dans votre cas, il ne s’agira pas réellement de TDD (si vous voulez vraiment voir en quoi cela consiste, vous pouvez trouver plein d’exemples sur Internet), mais vous suivrez les étapes ci-dessous afin de vous habituer à écrire le code appelé uniquement à partir de ce que le code appelant requiert :

1. Décommenter la prochaine ligne du main.
2. Ecrire le code permettant de la faire compiler.
3. Compiler et tester.
4. Si ça ne fonctionne pas, modifier le code, et recommencer à partir de l’étape 3.
5. Si ça fonctionne, recommencer à partir de l’étape 1, jusqu’à ce que tout le code du main soit décommenté.

Définition d’une classe

Voici la syntaxe permettant de définir une classe A :

class A
{
};

Attention à ne pas oublier le point virgule ; après l’accolade fermante. Il s’agit d’une erreur classique.

Décommentez la première instruction du main, permettant d’instancier une variable p de type Person, et définissez la classe correspondante juste au-dessus du main.
Compilez et testez que le programme se lance correctement.

#include <iostream>

class Person
{
};

int main()
{
    Person p;
    /* ... */
}

g++ -std=c++17 -o 2-first-class 2-first-class.cpp

Définition des membres (attributs et fonctions-membres)

Pour définir des membres dans une classe, il faut dans un premier temps choisir leur visibilité. En C++, cela se fait à l’aide des mots-clefs public, private et protected. Dans ce chapitre, nous n’utiliserons que les deux premiers.

Voici un exemple de classe définissant des fonctions-membres publiques et des attributs privés :

class SomeClass
{
public:
    void fcn1(int p1, int p2)
    {
        // code
    }

    int fcn2(bool p1)
    {
        // code
    }

private:
    int         _member1 = 0;
    std::string _member2;
};

Vous allez maintenant décommenter l’instruction permettant d’appeler la fonction set_name sur p.
Ajoutez ensuite un attribut _name à la classe Person et implémentez la fonction-membre set_name permettant de modifier cet attribut.
Quelle visibilité avez-vous choisi pour _name et set_name ?

Compilez et testez que le code s’exécute correctement.

class Person
{
public:
    void set_name(std::string name) { _name = name; }

private:
    std::string _name;
};

Modification d’un attribut

Décommentez l’instruction faisant l’appel à set_age, et définissez la fonction ainsi que l’attribut correspondants.
Quel type avez-vous utilisé pour l’âge de Batman ?

class Person
{
public:
    void set_name(std::string name) { _name = name; }
    void set_age(unsigned int age) { _age = age; }

private:
    std::string  _name;
    unsigned int _age;
};

Il y a un problème dans le code solution donné juste au dessus. Trouvez-le et corrigez-le.

int main()
{
    Person p;

    p.set_name("Batman");
    // p.set_age(23);

    // std::cout << "Person named '" << p.get_name() << "' is " << p.get_age() << " years old." << std::endl;

    return 0;
}

class Person
{
public:
    void set_name(std::string name) { _name = name; }
    void set_age(unsigned int age) { _age = age; }

private:
    std::string  _name;
    unsigned int _age = 0u;
};

Pourquoi le même problème ne se pose pas pour l’autre attribut?

Fonction-membre constante

Il ne reste plus qu’une seule ligne à décommenter. Vous devrez ici implémenter deux accesseurs (ou getters), un pour le nom et un pour l’âge.

Les accesseurs sont des fonctions qui ne sont pas censées modifier l’état de l’objet lorsqu’elles sont appelées. En C++, on spécifie cette garantie en plaçant le mot-clef const à la fin de la signature de la fonction.

public:
    int get_value() const { return _value; }

Dès lors qu’une fonction-membre est marquée const, le compilateur va vérifier qu’aucune modification n’est effectuée sur les attributs de l’objet. Le code suivant ne compilera donc pas :

class SomeClass
{
public:
    int set_and_get(int value) const
    {
        _value = value;
        return _value;
    }

private:
    int _value = 0;
};

Revenons à notre exercice. Décommentez la dernière instruction du main, implémentez les deux accesseurs nécessaires (sans oublier leur const 🙃) et vérifiez que le programme fonctionne.

public:
    std::string  get_name() const { return _name; }
    unsigned int get_age() const  { return _age; }

    ...

Synthèse

• Les classes peuvent contenir des attributs et des fonctions-membres.
• La définition d’une classe se termine toujours par un ;
• On utilise public: ou private: devant un groupe de champs pour indiquer s’ils sont publics ou privés.
• Si une fonction-membre n’a pas vocation à changer l’état de l’objet, il faut indiquer qu’elle est const (à placer derrière les parenthèses des paramètres).