Couplage de classes lâches et accès aux données

Question

J'essaie d'implémenter une classe compliquée dont la construction nécessite la spécification d'une condition qui permet au constructeur de déterminer quand l'objet a été construit. Prenons, par exemple:

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

Voici ce que le constructeur pourrait ressembler à:

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

J'imagine TerminateCondition être une classe abstraite.

demande 1: Accès aux membres RigidBody

Je voudrais class TerminateConditionAtRest: public TerminateCondition pouvoir utiliser trajectory_, pour que je puisse mettre fin à des conditions telles que std::abs(trajectory.back() - trajectory_[0]) < epsilon. Aurais-je besoin de forcer Done(...) à prendre un vector const & en tant qu'argument d'entrée et lui transmettre trajectory_?

demande 2: flexibilité avec la signature de Done(...)

je pourrais vouloir class TerminateConditionNumSteps: public TerminateCondition pour marquer Done quand n > 1000 ou quelque chose de similaire. Fondamentalement, je pourrais utiliser une certaine flexibilité avec le /* Signature */ là-bas.

Comment puis-je obtenir une telle configuration, dans laquelle TerminateCondition->Done peut utiliser aussi divers un ensemble de variables disponibles dans le cadre du constructeur RigidBody, tels que les membres privés comme trajectory_ ou locaux comme n? Je cherche juste la flexibilité ultime dans la modélisation de la condition de terminaison de boucle. Il ne semble pas qu'une classe abstraite permette d'être flexible avec la signature d'argument en entrée. D'un autre côté, une classe abstraite semble être la seule chose qui me permettrait de spécifier la condition à l'exécution.

Merci.

Answer 1

C'est juste ma pensée. Peut-être que vous voulez utiliser quelque chose comme ça ?:

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

Ensuite, vous pouvez créer la trajectoire spécifique que vous voulez:

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

L'idée principale de cette solution est logique de mouvement de la création de la trajectoire dans la classe séparée