C++ - Vorlagen und Vererbung

Question

Mein C++ - Framework verfügt über Schaltflächen. Ein Button stammt von Control. Eine Funktion, die ein Control akzeptiert, kann also einen Button als Argument verwenden. So weit, ist es gut.

Ich habe auch Liste < T>. Die Liste < Schaltfläche> stammt jedoch nicht von der Liste < Steuerung> ab, was bedeutet, dass eine Funktion, die eine Liste von Steuerelementen akzeptiert, keine Liste von Schaltflächen als Argument verwenden kann. Das ist unglücklich.

Vielleicht ist dies eine dumme Frage, aber ich sehe nicht, wie kann ich diese lösen :(Liste < Knopf > von Liste < Steuer > ableiten sollte, aber ich sehe keinen Weg, dies automatisch geschehen lassen“ “.

Answer 1

Ich hasse es zu sagen, aber wenn Sie eine Liste von Instanzen zu Control anstelle von Zeigern zu Control verwenden, werden Ihre Schaltflächen sowieso Müll (Google "Objekt Slicing"). Wenn es sich um Listen von Zeigern handelt, dann machen Sie entweder list<button*> in list<control*>, wie andere vorgeschlagen haben, oder kopieren Sie eine neue list<control*> aus der list<button*> und übergeben Sie stattdessen diese in die Funktion. Oder schreiben Sie die Funktion als Vorlage neu.

Also, wenn Sie zuvor eine Funktion haben doSomething genannt, die eine Liste von Kontrollen als Argument hat, würden Sie es umschreiben als:

template <class TControl> 
void doSomething(const std::list<TControl*>& myControls) { 
    ... whatever the function is currently doing ... 
} 

void doSomethingElse() { 
    std::list<Button*> buttons; 
    std::list<Control*> controls; 
    doSomething(buttons); 
    doSomething(controls); 
} 

Answer 2

Wie wäre es mit Zeigern? haben Sie einfach eine Liste von list<Control*> und setzen, was Kontrolle abgeleitete Objekte, die Sie in sie mögen.

Answer 3

Statt Liste mit < Knopf >, Verwendung Liste < Steuerung * >, das sind zeigt auf Buttons. So hat Ihre Funktion nur um einen Typ zu nehmen: Liste < Kontrolle * >.

Answer 4

Stroustrup hat einen Artikel zu diesem Thema in seiner FAQ:

Why can't I assign a vector<Apple*> to a vector<Fruit*>

Sie es auf zwei Arten lösen:

• Machen Sie die Liste Zeiger auf Control enthalten. Dann akzeptieren Sie List<Control*>
• Machen Sie Ihre Funktion zu einer Vorlage. Sie können immer noch List<Button> und List<Control> verwenden, aber es ist mehr Vorabcode und nicht die meiste Zeit notwendig.

Hier ist Code für die zweite Alternative. Die erste Alternative wird bereits von anderen Antworten erklärt:

class MyWindow { 
    template<typename T> 
    void doSomething(List<T> & l) { 
     // do something with the list... 
     if(boost::is_same<Control, T>::value) { 
      // special casing Control 

     } else if(boost::is_same<Button, T>::value) { 
      // special casing Button 

     } 

    } 
}; 

doSomething für List<derived from Control>, einige mehr Code nur zu beschränken, ist (suchen Sie nach enable_if wenn Sie wissen wollen) benötigt.

Beachten Sie, dass diese Art von Code (suchen, welchen Typ Sie haben) eher zu vermeiden ist. Sie sollten solche Dinge mit virtuellen Funktionen behandeln. Fügen Sie zu Control eine Funktion doSomething hinzu, und überschreiben Sie es in Button.

Answer 5

Im Allgemeinen ist die C++ Art und Weise Algorithmen zu schreiben, die auf einer Liste ausführen , Sequenz, ...ist es, Iteratoren als Argumente bereitzustellen.

template < class iterator > 
doSomething(iterator beg, iterator end); 

Dies löst die Liste < Taste *> nicht aus Liste abgeleitet < Steuerung *>. (unter Verwendung einer Vorlage Liste < T *> würde auch, aber das ist irgendwie Ihre Funktion Generika-aber nicht-wirklich)

Meiner Erfahrung nach kann gute Template-Funktionen auf Iteratoren arbeiten eine Menge (zu viel ...) arbeiten, aber es ist die "C++ Art und Weise" ...

Wenn Sie diese Route gehen, erwägen Sie die Verwendung Boost.ConceptCheck. Es wird dein Leben viel einfacher machen.