Manière élégante/efficace de créer une classe spécifique à une autre classe d'une autre classe

Question

J'ai une classe appelée ToolConfigurationVector et une classe appelée JointVariableVector. Je dois être capable de convertir entre ces deux classes (ce sont des représentations différentes des mêmes données)

Un ToolConfigurationVector se compose de seulement 6 types de données primitifs. C'est toujours le cas.

A JointVariableVector est une représentation qui est spécifique à un Robotarm, représenté par la classeArm.

Donc, pour une sous-classe de Arm (par exemple SimpleArm) la représentation et donc la conversion à ToolConfigurationVector est tout à fait différente de la représentation et la conversion d'une autre sous-classe de Arm (par exemple ComplexArm)

Plus tard, je veux pour utiliser les classes comme ceci:

Arm * someArm = new ComplexArm(); 
// ... 
JointVariableVector jvv = someArm.currentJointVariableVector(); 
ToolConfigurationVector tcv = jvv.toToolConfigurationVector(); // no problem using virtual function 
JointVariableVector how = tcv.toJointVariableVector(); // how? 

Je ne veux pas inclure d'informations sur quelle sous-classe de Arm est utilisé dans ToolConfigurationVector, les informations doivent être stockées en quelque sorte dans JointVariableVector

Bien sûr, je pourrais utiliser des modèles comme celui-ci:

JointVariableVector<ComplexArm> how = ... 

Mais ce n'est pas applicable dans mon cas, je dois résoudre ce en utilisant SEULEMENT

• someArm
• tcv
• ToolConfigurationVector
• JointVariableVector

Je pourrais bien sûr donner Arm une méthode virtuelle comme jointVariableVectorFromToolConfigurationVector(ToolConfigurationVector v) mais je ne peux pas le rendre statique, et parce qu'il n'a rien à voir avec l'objet Arm réelle mise en œuvre comme méthode (sans statique) me semble faux. Que puis-je faire pour obtenir une solution élégante?

Bien sûr, cette solution devrait aussi être efficace (en termes de classes, d'objets et de temps d'exécution).

Answer 1

De jvv.toToolConfigurationVector(); // no problem using virtual function il indique que JointVariableVector détient un pointeur ou une référence à une instance de la sous-classe Arm, ou qu'il utilise quelque chose comme le modèle pImpl, afin de se livrer à un comportement virtuel dans la sous-classe Arm qu'il a été créé à partir.

Si vous voulez ToolConfigurationVector::toJointVariableVector créer une classe qui est virtuelle dans ce sous-classe de Arm est spécifique à, soit (A) ToolConfigurationVector doit être virtuel dans lequel la sous-classe de Arm le JointVariableVector sera virtuel en ce qu'elle produit, ou (B) ToolConfigurationVector::toJointVariableVector doit être fourni un Arm pour créer le JointVariableVector qui sera virtuel dans la sous-classe Arm. Par exemple, passez un Arm à toJointVariableVector.

Alternativement, le JointVariableVector pourrait être une sorte d'objet vierge qui doit être béni plus tard avec le contexte Arm avant que cela ne devienne logique, mais cela crée un désordre.

Donc, pour être clair, JointVariableVector a soit un pointeur vers un Arm (parce que sa représentation est une fonction dudit Arm), ou est une classe de modèle pImpl, en fonction de votre syntaxe (où les instances de JointVariableVector, et non comme des pointeurs pareil, invoque le comportement virtuel). Comment dit JointVariableVector est construit est une fonction de la Arm d'où il vient. Le ToolConfigurationVector perd cette information. Pour reconstruire un JointVariableVector, vous devez ensuite réinjecter le Arm dans la situation.

Si JointVariableVector est uniquement fonction du type de Arm (et non sur l'instance), alors vous pouvez faire toJointVariableVector une fonction de modèle sur le type de Arm il crée un JointVariableVector pour. Pour réduire ToolConfigurationVector dépendance sur Arm sous-classes, ont ToolConfigurationVector envoyer l'appel à une fonction de modèle libre sur le type de Arm, que vous pouvez ensuite mettre en œuvre à côté de chaque sous-classe Arm et modifier le JointVariableVector produit.

qui vous donne la syntaxe:

Arm * someArm = new ComplexArm(); 
// ... 
JointVariableVector jvv = someArm.currentJointVariableVector(); 
ToolConfigurationVector tcv = jvv.toToolConfigurationVector(); 
JointVariableVector how = tcv.toJointVariableVector<ComplexArm>();