Puis-je cast std::vector<Animal*> std::vector<Chien*> sans regarder chaque élément?

Vous pouvez utiliser std::transform. Il utilise toujours for() en interne, mais vous aurez à deux cordes de mise en œuvre:

#include <vector>
#include <algorithm>
using namespace std;

struct Animal { virtual ~Animal() {} };
struct Dog : Animal { virtual ~Dog() {} };

template<typename Target>
struct Animal2Target { Target* operator ()( Animal* value ) const { return dynamic_cast<Target*>(value); } };

void myDogCallback(vector<Animal*> &animals) {
{
    vector<Dog*> dogs;
    transform( animals.begin(), animals.end(), dogs.begin(), Animal2Target<Dog>() );
}

OriginalL'auteur Kirill V. Lyadvinsky

Il y a deux options. Le plus simple est d'utiliser quelque chose comme remove_copy_if. Je ne peux pas expliquer pourquoi ils l'appellent cela, mais il copie les éléments d'un récipient à un autre que ne pas satisfont le prédicat. Voici l'idée de base (non testé):

struct IsDog : unary_function < Animal *, bool > {
  bool operator ()(Animal * animal) const {
    return dynamic_cast <Dog*> (animal);
  }
};

void foo (vector<Animal*> animals) {
  vector<Dog*> dogs;
  std::remove_copy_if (animals.begin ()
    , animals.end ()
    , back_inserter (dogs)
    , std::not1 ( IsDog () ) );  //not1 here negates the result of IsDog!


  //dogs now contains only animals that were dogs

}

Je suppose, une manière de regarder la remove_copy_if est à croire que c'est copy_unless.

Une approche alternative, si vous basez votre code autour des itérateurs seulement, consiste à envelopper l'itérateur pour vector < Animal* > avec celui qui renvoie uniquement les chiens de la collection. Le principal avantage ici est que vous devez toujours avoir un seul conteneur, mais bien sûr, vous payez un peu plus, puisque vous êtes algorithme de naviguer sur l'ensemble de la collection d'animaux.

class dog_iterator  //derive from std::iterator probably with bidirectinoal tag
{
private:
  vector<Animals*>::iterator getNextDogIter (vector<Animals*>::iterator iter) {
    while (iter != m_end) {
      if (0 != dynamic_cast<Dog*> (*iter)) {
        break;
      }
      ++iter;
    }
    return iter;
  }

public:
  dog_iterator (vector<Animals*>::iterator iter, vector<Animals*>::iterator end)
  : m_end (end)
  , m_iter (getNextDogIter (iter))
  {
  }

  //... all of the usual iterator functions

  dog_iterator & operator++ ()
  {
    //check if m_iter already is at end - otherwise:
    m_iter = getNextDogIter (m_iter + 1);
    return *this;
  }
  //...
};

C'est très brouillon, mais j'espère qu'il vous montre le principe de base.

OriginalL'auteur Richard Corden

Si vous dites que vous pouvez garantir que chaque élément est vraiment un Chien puis juste static_cast c'est à dire

void myDogCallback(vector<Animal*> &animals) {

    const vector<Animal*>::size_type numAnimals = animals.size();

    vector<Dog*> dogs;
    dogs.reserve( numAnimals );

    for ( vector<Animal*>::size_type i = 0; i < numAnimals; ++i ) {
        dogs.push_back(static_cast<Dog*>( animals[i] ));
    }
}

J'ai l'habitude de toujours obtenir une réaction réflexe de gens que ce qui est mauvais et vous devriez toujours utiliser dynamic_cast mais, en réalité, si vous pouvez donner des garanties sur le type, alors il est parfaitement sûr et de l'OMI une chose sensée à faire.

Aussi, votre garantie impliquerait que le nouveau vecteur a la même taille afin de réserver le même espace d'éviter de faire la répartition dans chaque push_back. Comme une alternative boucle, j'ai utilisé un indice juste parce que je pense toujours à une itération à l'aide d'un index doit être plus rapide que celle d'un itérateur, mais c'est sans doute absurde 🙂

OriginalL'auteur Troubadour

Le mélange de la std::transform méthodologie avec un static_cast (parce que vous êtes certains de ses sécurité) pourrait ressembler à:

std::transform(animals.begin(), animals.end(),
               std::back_insert_iterator<std::vector<Dog*>>(dogs),
               [](auto ptr) { return static_cast<Dog*>(ptr); });

OriginalL'auteur Escualo