Pourquoi utiliserait-on des classes imbriquées en C ++?

Quelqu'un peut-il s'il vous plaît me diriger vers de belles ressources pour comprendre et utiliser des classes imbriquées? J'ai du matériel comme les principes de programmation et des choses comme ce centre de connaissances IBM - Classes imbriquées

Mais j'ai toujours du mal à comprendre leur but. Quelqu'un pourrait-il m'aider s'il vous plaît?

Les classes imbriquées sont cool pour cacher les détails de l'implémentation.

Liste:

class List
{
    public:
        List(): head(nullptr), tail(nullptr) {}
    private:
        class Node
        {
              public:
                  int   data;
                  Node* next;
                  Node* prev;
        };
    private:
        Node*     head;
        Node*     tail;
};

Ici, je ne veux pas exposer Node car d'autres personnes pourraient décider d'utiliser la classe et cela m'empêcherait de mettre à jour ma classe car tout ce qui est exposé fait partie de l'API publique et doit être maintenu pour toujours . En rendant la classe privée, je cache non seulement l'implémentation, je dis aussi que c'est la mienne et je peux la changer à tout moment pour que vous ne puissiez pas l'utiliser.

Regardez std::listou std::mapils contiennent tous des classes cachées (ou le font-ils?). Le fait est qu'ils peuvent ou non, mais parce que l'implémentation est privée et cachée, les constructeurs de la STL ont pu mettre à jour le code sans affecter la façon dont vous avez utilisé le code, ou laisser beaucoup de vieux bagages traînant autour de la STL parce qu'ils ont besoin pour maintenir la compatibilité ascendante avec un imbécile qui a décidé d'utiliser la classe Node qui était cachée à l'intérieur list.

Les classes imbriquées sont comme les classes normales, mais:

• ils ont une restriction d'accès supplémentaire (comme toutes les définitions à l'intérieur d'une définition de classe),
• ils ne polluent pas l'espace de noms donné , par exemple l'espace de noms global. Si vous pensez que la classe B est si profondément connectée à la classe A, mais que les objets de A et B ne sont pas nécessairement liés, alors vous voudrez peut-être que la classe B ne soit accessible que via l'étendue de la classe A (elle serait appelée A ::Classe).

Quelques exemples:

Classe d'imbrication publique pour la placer dans une portée de classe pertinente

Supposons que vous souhaitiez avoir une classe SomeSpecificCollectionqui regrouperait des objets de classe Element. Vous pouvez alors soit:

1. déclarer deux classes: SomeSpecificCollectionet Element- mauvais, car le nom "Element" est assez général pour provoquer un éventuel conflit de nom

2. introduire un espace de noms someSpecificCollectionet déclarer les classes someSpecificCollection::Collectionet someSpecificCollection::Element. Pas de risque de clash de nom, mais peut-il devenir plus bavard?

3. déclarer deux classes globales SomeSpecificCollectionet SomeSpecificCollectionElement- ce qui a des inconvénients mineurs, mais c'est probablement OK.

4. déclarer la classe globale SomeSpecificCollectionet la classe Elementcomme sa classe imbriquée. Ensuite:

   • vous ne risquez aucun conflit de nom car Element n'est pas dans l'espace de noms global,
   • dans la mise en œuvre de SomeSpecificCollectionvous faites référence à juste Element, et partout ailleurs comme SomeSpecificCollection::Element- ce qui ressemble + - à la même chose que 3., mais plus clair
   • il est clair que c'est "un élément d'une collection spécifique", pas "un élément spécifique d'une collection"
   • il est visible que SomeSpecificCollectionc'est aussi une classe.

À mon avis, la dernière variante est certainement la conception la plus intuitive et donc la meilleure.

Permettez-moi de souligner - Ce n'est pas une grande différence de créer deux classes globales avec des noms plus verbeux. C'est juste un tout petit détail, mais à mon avis, cela rend le code plus clair.

Présentation d'une autre portée dans une portée de classe

Ceci est particulièrement utile pour introduire des typedefs ou des enums. Je vais juste poster un exemple de code ici:

class Product {
public:
    enum ProductType {
        FANCY, AWESOME, USEFUL
    };
    enum ProductBoxType {
        BOX, BAG, CRATE
    };
    Product(ProductType t, ProductBoxType b, String name);

    // the rest of the class: fields, methods
};

On appellera alors:

Product p(Product::FANCY, Product::BOX);

Mais quand on regarde les propositions de complétion de code pour Product::, on obtiendra souvent toutes les valeurs d'énumération possibles (BOX, FANCY, CRATE) et il est facile de faire une erreur ici (les énumérations fortement typées de C ++ 0x résolvent en quelque sorte cela, mais tant pis ).

Mais si vous introduisez une portée supplémentaire pour ces énumérations en utilisant des classes imbriquées, les choses pourraient ressembler à ceci:

class Product {
public:
    struct ProductType {
        enum Enum { FANCY, AWESOME, USEFUL };
    };
    struct ProductBoxType {
        enum Enum { BOX, BAG, CRATE };
    };
    Product(ProductType::Enum t, ProductBoxType::Enum b, String name);

    // the rest of the class: fields, methods
};

Ensuite, l'appel ressemble à:

Product p(Product::ProductType::FANCY, Product::ProductBoxType::BOX);

Ensuite, en tapant Product::ProductType::un IDE, on obtiendra uniquement les énumérations de la portée souhaitée suggérée. Cela réduit également le risque de faire une erreur.

Bien sûr, cela n'est peut-être pas nécessaire pour les petites classes, mais si l'on a beaucoup d'énumérations, cela facilite les choses pour les programmeurs clients.

De la même manière, vous pouvez «organiser» un grand nombre de typedefs dans un modèle, si jamais vous en aviez besoin. C'est parfois un modèle utile.

L'idiome PIMPL

Le PIMPL (abréviation de Pointer to IMPLementation) est un idiome utile pour supprimer les détails d'implémentation d'une classe de l'en-tête. Cela réduit le besoin de recompiler les classes en fonction de l'en-tête de la classe chaque fois que la partie "implémentation" de l'en-tête change.

Il est généralement implémenté à l'aide d'une classe imbriquée:

Xh:

class X {
public:
    X();
    virtual ~X();
    void publicInterface();
    void publicInterface2();
private:
    struct Impl;
    std::unique_ptr<Impl> impl;
}

X.cpp:

#include "X.h"
#include <windows.h>

struct X::Impl {
    HWND hWnd; // this field is a part of the class, but no need to include windows.h in header
    // all private fields, methods go here

    void privateMethod(HWND wnd);
    void privateMethod();
};

X::X() : impl(new Impl()) {
    // ...
}

// and the rest of definitions go here

Ceci est particulièrement utile si la définition de classe complète a besoin de la définition de types à partir d'une bibliothèque externe qui a un fichier d'en-tête lourd ou juste moche (prenez WinAPI). Si vous utilisez PIMPL, vous pouvez inclure une fonctionnalité spécifique à WinAPI uniquement dans .cppet ne jamais l'inclure dans .h.

Je n'utilise pas beaucoup les classes imbriquées, mais je les utilise de temps en temps. Surtout quand je définis une sorte de type de données, et que je veux ensuite définir un foncteur STL conçu pour ce type de données.

Par exemple, considérons une Fieldclasse générique qui a un numéro d'identification, un code de type et un nom de champ. Si je veux rechercher un vectorde ces Fields par numéro d'identification ou par nom, je pourrais construire un foncteur pour le faire:

class Field
{
public:
  unsigned id_;
  string name_;
  unsigned type_;

  class match : public std::unary_function<bool, Field>
  {
  public:
    match(const string& name) : name_(name), has_name_(true) {};
    match(unsigned id) : id_(id), has_id_(true) {};
    bool operator()(const Field& rhs) const
    {
      bool ret = true;
      if( ret && has_id_ ) ret = id_ == rhs.id_;
      if( ret && has_name_ ) ret = name_ == rhs.name_;
      return ret;
    };
    private:
      unsigned id_;
      bool has_id_;
      string name_;
      bool has_name_;
  };
};

Ensuite, le code qui a besoin de rechercher ces Fields peut utiliser la matchportée dans la Fieldclasse elle-même:

vector<Field>::const_iterator it = find_if(fields.begin(), fields.end(), Field::match("FieldName"));

On peut implémenter un modèle Builder avec une classe imbriquée . Surtout en C ++, personnellement je le trouve sémantiquement plus propre. Par exemple:

class Product{
    public:
        class Builder;
}
class Product::Builder {
    // Builder Implementation
}

Plutôt que:

class Product {}
class ProductBuilder {}