Gießen derivedclassptrVector von baseclassptrVec, den besten Weg?

Question

Ich erhalte Basisklasse Zeiger Vektor, der abgeleiteten Klasse Zeiger Vektor übergeben werden benötigt, schlagen Sie bitte besten Weg, das gleiche zu tun.

Ein Weg wird

eine neue abgeleitete Klasse Vektors mit der Vektorgröße ptr

Schleife der ankommende Vektor

dynamische Umwandlung der Basiszeiger und füllen den abgeleiteten Vektor Basisklasse erstellen.

Bitte schlagen Sie vor, wenn es eine bessere Möglichkeit gibt zu überzeugen, dass der Vektor für die polymorphen Typen ist.

Answer 1

Wenn ich die Frage richtig zu verstehen, müssen Sie die folgende Situation

class Base {}; 
class Derived: public Base {}; 
class Derived2: public Base {}; 

void foo(const vector<Derived*>&); 

void bar() 
{ 
    vector<Base*> baseVec; 

    // Fill baseVec with pointers to Derived objects 

    foo(baseVec); // Does not work 
} 

Das Problem ist, dass, obwohl Base und Derived durch Vererbung verwandt sind, die Typen vector<Base*> und vector<Derived*> sind völlig unabhängig. Es gibt keine Konvertierung zwischen den beiden.
Auch gibt es das zusätzliche Problem, dass baseVec könnte auch Zeiger auf andere abgeleitete Klassen, wie Derived2, und foo kann nicht mit diesen umzugehen.

Die einzigen wirklichen Lösungen sind

• die in der Frage vor: ein neues vector<Derived*> erstellen und das Auffüllen mit dynamic_cast ed Inhalt des Quellvektors
• vermeiden, einen Typenkonflikt im Programm hat, so.

Answer 2

Ich denke, was Sie ist die rechtliche Art und Weise erwähnt. Wenn Sie den Vektor selbst zu werfen haben, werden einige Assertionsfunktion wie die Ihren Zweck folgende dienen?

struct A { 
    virtual ~A() {} 
}; 

struct B : A {}; 

template< class Derived, class Base > 
vector<Derived> const* dynamic_cast_vector(vector<Base> const& x) 
{ 
    for (typename vector<Base>::const_iterator i = x.begin(), e = x.end(); 
     i != e; 
     ++ i) { 
    if (! dynamic_cast<Derived>(*i)) return 0; 
    } 

    return (vector<Derived> const*) &x; 
} 

int main() 
{ 
    vector< A* > av(1, new A), bv(1, new B); 
    dynamic_cast_vector< B* >(av); // null 
    dynamic_cast_vector< B* >(bv); // ok 
} 

this helps

Answer 3

Wenn Sie sicher sind, dass Ihr baseclassptrVector nur derivedclass Zeiger hat, können Sie den C++ Typ umgehen mit der Überprüfung:

derivedclassptrVector = reinterpret_cast<std::vector<derivedclass *> &>(baseclassptrVector);