Zugriff auf Sammlung von abstrakten Klassen

Question

Ich entwerfe eine Schnittstelle (eine abstrakte Klasse) in C++, die Art von Baumstruktur implementiert: jede Instanz hat null, eine oder mehrere Kinder. Die Kinder sind auch Instanzen der Schnittstelle.

Ich habe in der Regel ziemlich viel über eine Schnittstelle nachgedacht, um bestimmte Implementierungen nicht auszuschließen. Zum Beispiel sollten Methoden keine Referenzen zurückgeben, da dies die Implementierung zwingt, den Wert irgendwo zu speichern. Dies würde Implementierungen ausschließen, die den Wert bei jedem Aufruf neu berechnen. oder Wrapper, die den zurückgegebenen Wert in irgendeiner Weise transformieren.

Mit dieser Schnittstelle bin ich jedoch unsicher über die beste Möglichkeit, den Kindern einer Instanz den Zugriff zu ermöglichen. Bisher habe ich mit zwei Optionen kommen:

class Interface 
{ 
public: 

    virtual ~Interface() = default; 

    // IDEA 1: return a collection of references. 
    virtual auto getChildren() const -> std::vector<std::reference_wrapper<Interface>> = 0; 

    // IDEA 2: accept a visitor. 
    virtual void visitChildren(const std::function<void(Interface&)> &visitor) const = 0; 

}; 

---

Meine Frage:, was das Beste ist * Art und Weise Zugang zu einer Sammlung von abstrakten Klassen zur Verfügung zu stellen. Andere Ideen und Ansätze werden sehr geschätzt (z. B. ein Iterator-basierter Ansatz, wenn überhaupt möglich).

* Einige oder alle der folgenden Eigenschaften: Die meisten idiomatische, flexibelste, skalierbarste, die meisten wartbar, intuitivste, semantisch stärkste, ...

Answer 1

Platzierung der Diskussion über Ihr Design beiseite zu Java-like sein . Wenn Sie idiomatische C sein wollen ++, gehen Sie für Iteratoren:

class Interface { 
    class iterator_impl { 
    virtual ~iterator_impl() = default; 
    // Fill the rest 
    }; 
public: 
    class iterator { 
    std::unique_ptr<iterator_impl> _impl; 
    iterator(std::unique_ptr<iterator_impl> impl) : _impl(std::move(impl)) {} 
    public: 
    Iterface& operator*() { 
     //forward to _impl 
    } 
    }; 

    virtual iterator begin() = 0; 
    virtual iterator end() = 0; 
}; 

Nach der vollständigen Iterator-Protokoll liefert, kann ein Interface& in idiomatischen C++ Code verwendet werden:

void foo(Interface& interface) { 
    for(auto& i : interface) { 
    //Do stuff 
    } 
}