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 apparenté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 vous avez apprises. Une classe imbriquée déclarée dans la section privée n'est accessible qu'à l'intérieur de la classe externe.

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

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

Un détail important : la classe imbriquée n'a pas automatiquement accès aux membres privés de la classe externe. Ce sont des classes distinctes qui partagent simplement un espace de noms.

Si la classe imbriquée a besoin d'un accès, vous devez la déclarer comme friend, comme illustré dans l'exemple ci-dessus.

Défi

Facile

Construisons un système simple de gestion de tâches où les tâches sont organisées au sein d'un projet. C'est un scénario parfait pour les classes imbriquées — une Task n'a de sens que dans le contexte d'un Project, nous l'imbriquerons donc à l'intérieur pour garder notre code organisé et éviter de polluer l'espace de noms global.

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

Project.h : Définissez une classe Project qui contient une classe imbriquée Task.
Votre classe imbriquée Task doit être déclarée dans la section public de Project afin qu'elle puisse être accessible de l'extérieur. Elle doit stocker un nom de tâche (string) et un statut 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 statut, et getName() pour récupérer le nom.

La classe Project elle-même doit stocker un nom de projet (string) et une collection de pointeurs 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 trouve et termine une tâche par son nom, et une méthode displayStatus() qui affiche le nom du projet suivi du statut de chaque tâche.

Puisque Task est imbriquée dans Project, la classe Project peut travailler directement avec les tâches. N'oubliez pas de nettoyer les tâches allouées dynamiquement dans le destructeur.
main.cpp : Rassemblez le tout en lisant un nom de projet et deux noms de tâches à partir de l'entrée (trois lignes au total). Créez un Project avec le nom donné, ajoutez-y les deux tâches, puis affichez le statut initial. Terminez la première tâche et affichez à nouveau le statut pour montrer le changement.

Le format de sortie pour displayStatus() doit être :
```
Project: <project_name>
  - <task_name>: [incomplete]
  - <task_name>: [complete]
```
Utilisez [complete] ou [incomplete] selon le statut de chaque tâche.

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

Aide-mémoire

Une classe imbriquée est une classe définie à l'intérieur d'une autre classe. Elle aide à organiser le code en regroupant les types liés et améliore l'encapsulation.

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) {}
};

Les classes imbriquées suivent les règles d'accès standard. Une classe imbriquée dans la section privée n'est accessible qu'à l'intérieur de la classe externe. Lorsqu'elle est déclarée publique, le code externe peut l'utiliser avec l'opérateur de portée :

LinkedList::Node node(42);    // Uniquement si Node est publique

La classe imbriquée n'a pas automatiquement accès aux membres privés de la classe externe. Si l'accès est nécessaire, déclarez-la comme amie (friend) :

friend class LinkedList;

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