Lose Klassenkopplung und Datenzugriff

Question

Ich versuche eine komplizierte Klasse zu implementieren, deren Konstruktion die Spezifikation einer Bedingung erfordert, die es dem Konstruktor ermöglicht, zu bestimmen, wann das Objekt konstruiert wurde. Betrachten wir zum Beispiel:

class RigidBody 
{ 
    private: 
     std::vector<double> trajectory_; 
     // Other stuff... 
    public: 
     RigidBody(std::unique_ptr<TerminateCondition>, std::vector<double> const &); 
     // Other stuff... 
}; 

Hier ist, was der Konstruktor könnte wie folgt aussehen:

RigidBody::RigidBody(std::unique_ptr<TerminateCondition> condition, std::vector<double> const &p) 
{ 
    int n = 0; 
    while(!condition->Done(/* Signature */)) 
    { n++; 
     /* Do other stuff... */ 
     // such as, trajectory_.push_back(sin(n * dt)); 
    } 
} 

ich TerminateCondition vorstellen, eine abstrakte Klasse zu sein.

Nachfrage 1: Der Zugang zu RigidBody Mitglieder

ich class TerminateConditionAtRest: public TerminateCondition möchte der Lage sein, trajectory_ zu verwenden, so dass ich auf Bedingungen wie std::abs(trajectory.back() - trajectory_[0]) < epsilon beenden könnte. Müsste ich Done(...) zwingen, ein vector const & als ein Eingabeargument zu nehmen und trajectory_ an es zu übergeben?

Nachfrage 2: Flexibilität mit Unterschrift von Done(...)

I class TerminateConditionNumSteps: public TerminateCondition zu Flagge Done wenn n > 1000 oder etwas Ähnliches wollen könnte. Grundsätzlich könnte ich etwas Flexibilität mit der /* Signature */ drin nutzen.

Wie erreiche ich eine solche Einrichtung, bei TerminateCondition->Done kann wie n Verwendung von so unterschiedlichen einer Reihe von Variablen zur Verfügung im Rahmen des RigidBody Konstruktor, wie private Mitglieder wie trajectory_ oder Einheimischen machen?

Ich bin nur auf der Suche nach ultimative Flexibilität bei der Modellierung der Schleife Abbruchbedingung. Es scheint nicht so, als ob eine abstrakte Klasse erlaubt, flexibel mit der Eingabeargumentsignatur zu sein. Auf der anderen Seite scheint eine abstrakte Klasse das einzige zu sein, was es mir erlauben würde, die Bedingung zur Laufzeit zu spezifizieren.

Danke.

Answer 1

Es ist nur mein Gedanke. Vielleicht wollen Sie so etwas benutzen ?:

class TrajectoryCreator 
{ 
public: 
    virtual vector<float> create(const vector<float>& path) = 0; 
} 

Dann können Sie bestimmte Flugbahn erstellen Sie wollen:

RigidBody(TrajectoryCreator& t, const vector<float> &p) 
    : trajectory_(t.create(p)) 
{} 

Leitgedanke dieser Lösung ist, bewegen Logik der Schaffung Bahn in separaten Klasse