CLASSES, OBJETS, CONSTRUCTEURS ET RAII

[Hydraxx]

CLASSES, OBJETS, CONSTRUCTEURS ET RAII

À QUOI ÇA SERT ?

Une classe permet de regrouper :

• un état ;
• des opérations ;
• des règles de durée de vie.

Pour le développement système, l’intérêt majeur n’est pas seulement "faire de l’OOP".

C’est surtout RAII.

RAII signifie :

Resource Acquisition Is Initialization.

L’idée :

"Je lie la durée de vie d’une ressource à celle d’un objet C++."


1. CLASSE SIMPLE

Code: Select all

class Counter
{
public:
    void increment()
    {
        ++value_;
    }

    int value() const
    {
        return value_;
    }

private:
    int value_{};
};

Utilisation :

Code: Select all

Counter c;
c.increment();

2. private


value_ est privé.

Pourquoi ?

Pour empêcher un code extérieur de casser l’état interne.

Tu imposes une interface.


3. CONSTRUCTEUR

Code: Select all

class Counter
{
public:
    Counter(int initial)
        : value_{initial}
    {
    }

private:
    int value_;
};

Le constructeur initialise l’objet.


4. LISTE D’INITIALISATION

Code: Select all

Counter(int initial)
    : value_{initial}
{
}

Pourquoi ne pas faire :

Code: Select all

Counter(int initial)
{
    value_ = initial;
}

Parce que dans le premier cas, value_ est directement construit avec initial.

Dans le second, il peut être construit d’abord puis affecté ensuite.

Pour un int la différence est minime.

Pour un objet complexe, cela compte.


5. DESTRUCTEUR

Code: Select all

~Counter()
{
}

Le destructeur est appelé lorsque la durée de vie de l’objet se termine.

C’est là que RAII devient puissant.


6. EXEMPLE AVEC UN HANDLE WINDOWS


Sans RAII :

Code: Select all

HANDLE h = CreateFileW(...);

if (h == INVALID_HANDLE_VALUE)
    return;

doSomething(h);

CloseHandle(h);

Le problème :

Si tu ajoutes plusieurs return ou exceptions, tu peux oublier CloseHandle.

Avec RAII :

Code: Select all

class UniqueHandle
{
public:
    explicit UniqueHandle(HANDLE h)
        : handle_{h}
    {
    }

    ~UniqueHandle()
    {
        if (handle_ != nullptr &&
            handle_ != INVALID_HANDLE_VALUE)
        {
            CloseHandle(handle_);
        }
    }

private:
    HANDLE handle_;
};

Maintenant, quand l’objet meurt, le handle est fermé automatiquement.


7. EXEMPLE LINUX


Même idée avec un file descriptor.

Code: Select all

class FileDescriptor
{
public:
    explicit FileDescriptor(int fd)
        : fd_{fd}
    {
    }

    ~FileDescriptor()
    {
        if (fd_ >= 0)
            close(fd_);
    }

private:
    int fd_;
};

8. POURQUOI RAII EST ÉNORME


RAII peut gérer :

• mémoire ;
• mutex ;
• fichiers ;
• sockets ;
• HANDLE ;
• sections critiques ;
• mappings ;
• transactions.

Exemple mutex :

Code: Select all

std::lock_guard lock{mutex};

Quand lock est détruit, le mutex est relâché.

Tu évites énormément de chemins d’erreur complexes.


9. this


Dans une méthode :

Code: Select all

this->value_

this est un pointeur vers l’objet courant.

Quand tu fais :

Code: Select all

c.increment();

la méthode sait sur quel objet elle travaille via this.


À RETENIR


Pour toi, les classes doivent surtout être vues comme :

• encapsulation ;
• gestion automatique de ressources ;
• RAII ;
• contrôle précis de durée de vie.

Pas uniquement comme "programmation orientée objet".