Je veux un vecteur de pointeurs de classe dérivés comme pointeurs de classe de base

En C++, la classe vector stocke un tableau d'objets. Dans ce cas, je suis de stocker des pointeurs vers des dérivés de la classe d'objets (les Chiens). À un certain point, je veux traiter ce vecteur de pointeurs vers des objets de la classe de base (les Animaux). C'est le "droit"/non controversée? Pourquoi ne puis-je pas le faire?

#include <vector>
using namespace std;

class Animal { }; 
class Dog : public Animal { };

int main(int argc, char *argv[]) {
    vector<Dog*> dogs;
    dogs.push_back(new Dog());
    dogs.push_back(new Dog());
    vector<Animal*> animals = dogs; //This doesn't seem to work.

    //This is really what I want to do...
    vector<Animal*> all_animals[] = {dogs, cats, birds};
}

L'erreur:

Untitled.cpp:11:18: error: no viable conversion from 'vector<class Dog *>' to 'vector<class Animal *>'
    vector<Animal*> animals = dogs;
                    ^         ~~~~
/usr/include/c++/4.2.1/bits/stl_vector.h:231:7: note: candidate constructor not viable: no known conversion from 'vector<Dog *>' to 'const std::vector<Animal *, std::allocator<Animal *> > &' for 1st argument
  vector(const vector& __x)
  ^

source d'informationauteur SharkCop

  1. 11

    Il y a un constructeur de copie pour un std::vector mais il vous oblige à copier exactement le même type de vecteur. Heureusement, il y a un autre constructeur qui prend une paire d'itérateurs et ajoute tous les éléments de la gamme, de sorte que vous pouvez le faire:

    vector<Animal*> animals(dogs.begin(),dogs.end());

    Cela crée un nouveau vecteur de Animal pointeurs en parcourant chaque Dog pointeur. Chaque Dog pointeur est converti en Animal pointeur comme il va.

    Voici un exemple plus complet (à l'aide de C++11):

    #include <vector>

struct Animal { };

struct Dog : Animal { };

struct Cat : Animal { };

struct Bird : Animal { };

int main(int,char**)
{
  Dog dog1, dog2;
  Cat cat1, cat2;
  Bird bird1, bird2;
  std::vector<Dog *> dogs = {&dog1,&dog2};
  std::vector<Cat *> cats = {&cat1,&cat2};
  std::vector<Bird *> birds = {&bird1,&bird2};
  std::vector<std::vector<Animal *>> all_animals = {
    {dogs.begin(),dogs.end()},
    {cats.begin(),cats.end()},
    {birds.begin(),birds.end()}
  };
}
  2. 0

    Vous pouvez Créer votre Chien Vecteur tel que:

    vector<Animal*> dogs;

    Et jeter votre chien les objets avant de les insérer

    dogs.push_back((Animal*)new Dog());

    Plus tard, rejetés lors de l'accès à

  3. 0

    Vous pouvez faire ce que vous voulez vraiment faire avec aucun problème du tout! C'est, il suffit de faire:

    class Animal {
   public:
      std::string GetNoise() const = 0;
};
class Dog : public Animal {
   public:
      std::string GetNoise() const { return "Bark!"; }
};
class Cat : public Animal {
   public:
      std::string GetNoise() const { return "Meow"; }
      bool        LikesSleeping() const { return true; }
};

Dog* d = new Dog;
Cat* c = new Cat;
vector<Animal*> all_animals;
all_animals.push_back(d, c);

//then, later...

//this will print "Bark!"
std::cout << all_animals[0]->GetNoise() std::endl;

//if you know the type somehow
Cat* x = dynamic_cast<Cat*>(all_animals[1]);
const bool y = x->LikesSleeping();

    La raison que votre code ne fonctionne pas de la façon que vous attendez, c'est que: std::vector<Dog*> est totalement classe différente de std::vector<Animal*>.

    En d'autres termes, le Chien hérite de l'Animal, oui, mais un std::vector<X> n'hérite pas de std::vector<Y> -- peu importe la façon dont X et Y sont liés!

    Modèles ne donnent pas le vecteur de beaucoup d'intelligence; ils viennent de définir une nouvelle classe. Vous pouvez pensez-y de cette façon:

    class vectorOfDogs {
    Dog* myDogs;
    //...
}

class vectorOfAnimals {
    Animal* myAnimals;
    //...
}

    Ne vectorOfDogs inhert de vectorOfAnimals? Clairement pas! Mais tout ce qui a été fait est de changer le nom de la classe à partir de std::vector<Dog*> à vectorOfDogs.