C++11 vecteur de pointeur intelligent

Supposons que nous avons les codes suivants. Nous avons des classes suivantes

  • Animal AbstractClass
  • Le chien et l'Oiseau qui est sous-classe de l'Animal
  • Zoo, qui conserve tous les animaux

_

class Animal
{
public:
    Animal();
    void HasWings() = 0;
};

class Bird : public Animal
{
public:
    Bird() : Animal() {}
    void HasWings() override { return true; }
};

class Dog : public Animal
{
public:
    Dog() : Animal() {}
    void HasWings() override { return false; }
};

class Zoo
{
public:
    Zoo() {}
    void AddAnimal(Animal* animal) { _animals.push_back(animal); }
    ...
    std::vector<Animal*> _animals;
};

void myTest()
{
    Zoo myZoo;
    Bird* bird = new Bird();
    Dog* dog = new Dog();

    myZoo.AddAnimal(bird);
    myZoo.AddAnimal(dog);

    for (auto animal : myZoo._animals)
    {
        ...
    }
    ...
}

J'espère remplacer vecteur de pointeurs par vecteur de pointeurs intelligents. j'.e, 

std::vector<std::shared_ptr<Animal>> _animals;

Comment faire pour changer le code de Zoo et myTest?
J'ai de la difficulté à trouver la mise à jour du code, en particulier la méthode "AddAnimal" dans le Zoo de classe

auto bird = std::make_shared<Bird>();
auto dog = std::make_shared<Dog>();
myZoo.AddAnimal(bird);
myZoo.AddAnimal(dog);

oiseau et le chien sont les différents type de

AddAnimal(std::shared_ptr<Animal> animal) - shared_ptr<Bird> et shared_ptr<Dog> convertir à shared_ptr<Animal> depuis les deux premiers sont des dérivés de ces derniers. Aussi Animal::HasWings est manquant virtual et puisque vous avez déjà une fonction membre virtuelle vous devriez aussi faire Animal's destructeur virtual

OriginalL'auteur user2434918 | 2015-02-26

  1. 9

    Le comportement de std::shared_ptr est très similaire à celle d'un pointeur brut à l'égard de la * et -> opérateurs (en fait, la référence à des opérateurs sont "transmis" à l'intérieur pointeur brut stocké par le std::shared_ptr). En particulier, vous pouvez utiliser un std::shared_ptr à une classe de base virtuelle expédition le long d'une hiérarchie de classe. Par exemple, le code ci-dessous fait exactement ce que l'on suppose, à savoir les appels de la fonction appropriée à l'exécution:

    #include <iostream>
#include <memory>
#include <vector>

struct Base
{
    virtual void f() { std::cout << "Base::f()" << std::endl;}
    virtual ~Base() = default; //to silence -Wall warnings
};

struct Derived: Base
{
    void f() override { std::cout << "Derived::f()" << std::endl;}
};

int main()
{
    std::vector<std::shared_ptr<Base>> vsp; //access Derived via shared_ptr to Base

    auto base = std::make_shared<Base>();
    auto derived = std::make_shared<Derived>();

    vsp.push_back(base);
    vsp.push_back(derived);

    for(auto&& elem: vsp)
        elem->f(); //virtual dispatch
}

    Donc, la plupart du temps, il suffit de remplacer le Animal* avec std::shared_ptr<Animal>, et le code tout fonctionne. Les choses sont un peu plus compliquées avec std::unique_ptr, que celle-ci est une déplacer uniquement de type (vous ne pouvez pas copier), donc on doit être plus prudent.

    Vous êtes de droite. Si j'utilise std::unique_ptr au lieu de std::shared_ptr parce que je ne peux pas créer une méthode pour retourner un pointeur de l'Animal, comme les vieux jours. c'est à dire, "Animal* GetAnimal(int index);"
    Dire de Base et Dérivés sont peu complexe des classes, avoir certaines fonctions et de membres, comment allez-vous, comment allez-vous détruire le vecteur vsp avant les principaux se termine et éviter la fuite de mémoire?
    le premier n' vsp.resize(0), alors vous pouvez aussi le faire base.reset(); derived.reset(); pour libérer la première partagé pointeurs (rappelez-vous que le compteur de référence est augmentée de 1 lorsque l'on pousse dans le vecteur).
    merci ça a aidé! 🙂

    OriginalL'auteur vsoftco