Comment empêcher l'ajout d'un objet dans plusieurs vecteurs?

Puisque tous les Movable , Ship et Bullet sont Drawable , pourquoi ne pas en créer un seul vecteur d'éléments Drawable et ajouter toutes les différentes classes à l'intérieur? Vous n'aurez qu'un seul pointeur vers toutes les différentes instances et vous n'aurez qu'un seul vecteur de ces pointeurs. Cette solution peut cependant nécessiter de faire de Drawable une classe abstraite.

En supposant que vous utilisez un compilateur raisonnablement moderne, c'est exactement pourquoi shared_ptr existe.

Le problème est que vous ne savez pas quel vecteur possède l'objet, donc vous ne savez pas lequel supprimer. Les prises shared_ptr sont pour vous: il gère la durée de vie de l'objet, et le supprimera une fois la dernière référence à l'objet détruite.

Pour créer un nouveau Expédier , vous pourriez faire quelque chose comme ceci:

auto ship = std::make_shared<Ship>();

drawables.push_back(ship);
movables.push_back(ship);
ships.push_back(ship);

À ce stade, ship a 4 références (une pour chaque vecteur, et la variable ship elle-même). Elle sera automatiquement supprimée une fois qu'elle aura été supprimée des trois vecteurs et que la variable locale sera hors de portée.

Si vous souhaitez conserver un conteneur de (pointeurs vers) tous les objets d'un certain type, vous pouvez adopter une approche RAII. Demandez au constructeur de l'objet d'ajouter au conteneur et au destructeur de le supprimer. Vous voudrez également vous assurer que rien d'autre ne modifie le conteneur, il devrait donc être un membre privé (statique) de votre classe, avec une méthode publique pour fournir un accès en lecture seule.

Encore mieux, déplacez cette logique dans son propre classe, donc il peut être réutilisé. Cela permettrait également à vos conteneurs existants de rester concentrés sur ce qu'ils font actuellement. Ils auraient juste besoin d'un nouveau membre de données du type de classe d'assistance.

Pour faciliter les suppressions, j'envisagerais d'utiliser une liste au lieu d'un vecteur . De plus, il peut être intéressant d'utiliser reference_wrapper au lieu de pointeurs. Un pointeur peut avoir une valeur nulle. Bien que vous puissiez documenter que le conteneur n'aura pas de pointeurs NULL, un reference_wrapper le transmet sans documentation supplémentaire.

Pour vous aider à démarrer, voici le début d'un modèle de classe d'assistance vous pourriez utiliser.

template <class T>
class All {
        using ListType = std::list< std::reference_wrapper<T> >;

    private:
        static ListType the_list;
        // A list's iterators are rarely invalidated. For a vector, you would
        // not store an iterator but instead search when removing from the_list.
        typename ListType::iterator list_it;

    public:

        // Read-only access to the list.
        static const ListType & list() { return the_list; }

        // Construction
        ListAll() : list_it(the_list.end()) {}  // If this constructor is needed
        explicit ListAll(T & data) : list_it(the_list.insert(the_list.end(), data)) {}

        // Destruction
        ~ListAll() { if ( list_it != the_list.end() ) the_list.erase(list_it); }

        // Rule of 5
        // You should also define or delete the copy constructor, move constructor,
        // copy assignment, and move assignment.

        // If you need the default constructor, then you probably want a method like:
        //void set(T & data);
};
template <class T>
typename All<T>::ListType All<T>::the_list{};

Les noms sont souvent difficiles à trouver. J'ai nommé ce modèle en fonction de l'obtention de quelque chose à parcourir, par exemple: All::list().