Kann ich warf std::vector<Tier*> std::vector<Hund*> ohne Blick auf jedes element?

Könnten Sie std::transform. Es verwendet immer noch for() intern, aber man bekommt zwei-string Umsetzung:

#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>() );
}

Gibt es zwei Möglichkeiten. Die einfachste ist die Verwendung von so etwas wie remove_copy_if. Ich kann nicht erklären, warum Sie nennen es das, aber es kopiert die Elemente von einem container zum anderen, dass nicht, die das Prädikat erfüllen. Hier ist die grundlegende Idee (ungetestet):

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

}

Glaube ich, ein Weg, um zu schauen remove_copy_if ist, zu denken, es als copy_unless.

Einen alternativen Ansatz, wenn Sie die Basis Ihres Codes um Iteratoren nur, umwickelt Sie den iterator für den vector < Tier* > mit einem, gibt nur die Hunde aus der Sammlung. Der entscheidende Vorteil hier ist, dass Sie immer noch nur ein container, aber natürlich ist Sie ein wenig mehr bezahlen, da Sie den Algorithmus für die Navigation über die gesamte Sammlung von Tieren.

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;
  }
  //...
};

Dies ist sehr rau, aber ich hoffe es zeigt das grundlegende Prinzip.

Wenn Sie sagen, dass Sie garantieren können, dass jedes element ist wirklich ein Hund dann nur static_cast d.h.

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] ));
    }
}

Ich in der Regel immer eine Kurzschlussreaktion von Menschen, das ist schlecht und man sollte immer dynamic_cast aber in Wirklichkeit, wenn Sie können, machen Sie garantiert über die Art dann ist es vollkommen sicher und IMO eine sinnvolle Sache zu tun.

Auch die Garantie würde bedeuten, dass der neue Vektor hat dieselbe Größe reservieren Sie also den gleichen Raum zu vermeiden, tun alle Zuordnungen, die in jedem push_back. Als alternative Schleife, die ich verwendet habe, einen index nur, weil ich immer denke, dass die Iteration mit index müssen schneller sein als ein iterator aber das ist ja wohl Quatsch 🙂

Mischen der std::transform Methodik mit einem static_cast (weil Sie sich sicher sind, dass seine Sicherheit) könnte wie folgt Aussehen:

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