Classes imbriquées et internes

Fait partie de la section Programmation Orientée Objet du Journey C++ de Coddy. Leçon 38 sur 104.

Une classe imbriquée est une classe définie à l’intérieur d’une autre classe. Cette technique aide à organiser le code en regroupant les types associés et peut améliorer l’encapsulation en masquant les détails d’implémentation.

class LinkedList {
public:
    class Node {    // Classe imbriquée
        int data;
        Node* next;
    public:
        Node(int d) : data(d), next(nullptr) {}
        friend class LinkedList;
    };
    
private:
    Node* head;
    
public:
    LinkedList() : head(nullptr) {}
};

La classe imbriquée Node est étroitement couplée à LinkedList : elle n’a de sens que dans ce contexte. En l’imbriquant, nous signalons cette relation et évitons de polluer l’espace de noms global avec un nom générique comme « Node ».

Les classes imbriquées suivent les mêmes règles d’accès que celles que vous avez apprises. Une classe imbriquée déclarée dans la section privée est accessible uniquement au sein de la classe externe.

Lorsqu’il est déclaré public, du code externe peut l’utiliser avec l’opérateur de portée :

LinkedList::Node node(42);    // Seulement si Node est public

Un détail important concernant la direction : une classe imbriquée est un membre de la classe englobante et dispose des mêmes droits d’accès que tout autre membre ; elle peut donc accéder aux membres privés de la classe englobante sans déclaration friend. L’inverse n’est toutefois pas automatique : la classe englobante n’a pas accès aux membres privés de la classe imbriquée.

C’est pourquoi Node déclare friend class LinkedList; dans l’exemple ci-dessus : la déclaration friend accorde à la LinkedList englobante l’accès aux membres privés de Node, la seule direction qui ne soit pas automatique.

Défi

Facile

Construisons un système simple de gestion des tâches, dans lequel les tâches sont organisées au sein d’un projet. C’est un scénario idéal pour les classes imbriquées : une Task n’a de sens que dans le contexte d’un Project, nous allons donc l’imbriquer à l’intérieur afin de garder notre code organisé et d’éviter de polluer l’espace de noms global.

Vous allez créer deux fichiers pour organiser votre code :

Project.h : Définir une classe Project qui contient une classe Task imbriquée.
Votre classe Task imbriquée doit être déclarée dans la section public de Project afin de pouvoir être accessible depuis l’extérieur. Elle doit stocker un nom de tâche (string) et un état d’achèvement (bool). Donnez-lui un constructeur qui prend le nom et définit la tâche comme incomplète par défaut. Incluez les méthodes complete() pour la marquer comme terminée, isComplete() pour vérifier son état et getName() pour récupérer son nom.

La classe Project elle-même doit stocker un nom de projet (string) et une collection de pointeurs vers des Task. Fournissez un constructeur qui prend le nom du projet, une méthode addTask(const std::string& taskName) qui crée une nouvelle tâche et l’ajoute au projet, une méthode completeTask(const std::string& taskName) qui recherche et termine une tâche par son nom, ainsi qu’une méthode displayStatus() qui affiche le nom du projet suivi de l’état de chaque tâche.

Comme Task est imbriquée dans Project, la classe Project peut travailler directement avec les tâches. N’oubliez pas de libérer les tâches allouées dynamiquement dans le destructeur.
main.cpp : Réunir tous les éléments en lisant un nom de projet et deux noms de tâches depuis l’entrée (trois lignes au total). Créez un Project avec le nom fourni, ajoutez-y les deux tâches, puis affichez l’état initial. Terminez la première tâche et affichez à nouveau l’état pour montrer la modification.
Le format de sortie de displayStatus() doit être :
```
Project: <project_name>
  - <task_name>: [incomplete]
  - <task_name>: [complete]
```
Utilisez [complete] ou [incomplete] en fonction de l’état de chaque tâche.

Ce défi montre comment les classes imbriquées aident à organiser les types associés : la classe Task est étroitement liée à Project et n’aurait pas de sens seule. En l’imbriquant, nous signalons clairement cette relation dans la structure de notre code.

Essayez vous-même

#include <iostream>
#include <string>
#include "Project.h"

using namespace std;

int main() {
    // Lire l'entrée
    string projectName;
    string task1Name;
    string task2Name;
    
    getline(cin, projectName);
    getline(cin, task1Name);
    getline(cin, task2Name);
    
    // TODO: Créer un Project avec le nom donné
    
    // TODO: Ajouter les deux tâches au projet
    
    // TODO: Afficher le statut initial
    
    // TODO: Terminer la première tâche
    
    // TODO: Afficher à nouveau le statut pour montrer le changement
    
    return 0;
}