Discussion :

[micamused]

Bonjour a tous,

merci à ceux qui liront et essayerons de m'aider.

Je me confronte a un probleme bien tordu qui releve surement d'un probleme de Design de mon code mais je trouve aucune solution valable la.

Voici le code (simplifié car je ne peux pas copier le code original qui est privé):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
class Addition: public IOperation
{
public:
 
	virtual ~Addition(){}
 
	//void DoOperation(Value a, Value b) const = 0;
 
};
 
//! Typedef
typedef boost::shared_ptr<const Addition> AdditionConstPtr;
 
 
/*!
       Templated Implementation
*/
template<typename Value>
class AdditionValue: public Addition, public OperationValue<Value>
{
public:
      AdditionValue();
 
      void DoOperation(Value a, Value b);
 
protected:
 
      //! Typedef
      typedef boost::shared_ptr<const AdditionValue<Value> > AdditionValueConstPtr;
 
private:
        Value m_AdditionResult;
}

Donc, on a une classe abstraite mere Addition et la classe AdditionValue qui permet de templétisé l'opération Addition suivant le type des données.

Ensuite dans le code on a une autre classe qui a un membre de type AdditionValue templétisée aussi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
template <typename Value>
class CheckOperationValue: public CheckOperation
{
 
     //! Typedef
     typedef boost::shared_ptr<const AdditionValue<Value> > AdditionValueConstPtr;
 
 
    //! Accessors
    AdditionConstPtr getAddition() const final;
 
private:
    mutable AdditionConstPtr m_AdditionCPtr;
}
 
template<typename Value>
AdditionConstPtr CheckOperationValue<Value>::getAddition() const
{
    if (! m_AdditionCPtr)
    {
        build_addition();
    }
 
    return m_AdditionCPtr;
}
 
template<typename Value>
void CheckOperationValue<Value>::build_addition() const
{
    // build Addition operator
    m_AdditionCPtr = AdditionValueConstPtr(boost::make_shared<AdditionValue<Value> >()));
}

et donc mon problème vient au moment ou dans mon code j'ai instancié un CheckOperation et je veux faire la chose suivante:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
 
double a, b;
 
...
 
auto checkOPCPtr = ...;
auto addOPCPtr = checkOPCPtr->getAddition();
addOPCPtr->DoOperation(a,b)

En effet, on a un pointeur sur la classe de base Addition (non templétisé) qui utilise une fonction membre de la classe templétisé AdditionValue, et donc je ne peux pas définir cette fonction dans la classe de base car pas de template. Si je crée la classe de base comme template, j'ai ensuite un autre problème du meme genre.

C'est assez compliqué et j'espere que mon exemple qui n'a aucun sens reprend bien le probleme dans mon contexte.

Merci de vos conseils en avance !!!

[skeud]

Il faut que tu passes par une classe qui encapsule la donnée, pas trop le choix autrement, héritage + template ça ne fonctionne pas des masses.

J'avais fait un truc dans ce gout là à l'époque:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
class Variant
{
public:
	template<typename T>
	void set(T data) {
		m_size = sizeof(data); m_data = new char[sizeof(data)]; memcpy(m_data, &data, sizeof(data));
	}
	template<typename T>
	void get(T& ret) { if (sizeof(ret) == m_size) memcpy(&ret, m_data, sizeof(ret)); }
	void* m_data = nullptr;
	size_t m_size = 0;
};
 
class Mere
{
public:
	Mere() {}
	template<typename T>
	T doOperation(T a, T b) { Variant v1, v2, result; v1.set(a); v2.set(b); doOperation(v1, v2, result); T res; result.get(res); return res;}
private:
	virtual void doOperation(Variant& a, Variant& b, Variant& result) = 0;
};
 
template<typename T>
class Fille : public Mere
{
public:
	Fille() {}
private:
	virtual void doOperation(Variant& a, Variant& b, Variant& result) override 
	{
		T v1;
		T v2;
		a.get(v1);
		b.get(v2);
		result.set(v1+v2); 
	};
};

à toi de reprendre pour pouvoir l'adapter et ajouter les cas d'erreur aussi pour pas que ça parte en vrille. Avec les nouveauté de c++, je crois que tu peux aussi stocker le typeId pour être sur que les données sont du même type (car le sizeof permet juste d'éviter le crash et non la transformation de donnée).

[micamused]

Merci pour ta réponse, je dois y réfléchir un peu, car dans mon cas je suis obligé d'utiliser un template car mon code est intégré avec une librairie de différentiation automatique (FADBAD) et donc pour pouvoir utiliser les fonctionnalités, il faut que le type soit générique.

Donc je suis pas sur de pouvoir créé mon propre type générique, en tout cas c'est une bonne idée merci.

D'un autre coté, j'ai vu des gens faire des dynamic_cast pour forcer à etre avec l'objet templatisé, mais ça résout pas tous les problèmes je pense.

Je reste ouvert à d'autres idées ...

[micamused]

Bon, apparemment la solution était pas si compliquée que ça, il fallait déclaré ma fonction comme template dans la classe de base:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
template<typename Value>
void DoOperation(Value a, Value b) const{ Raise Exception("Method not implemented here");}

[skeud]

Sauf que si tu fais ça, tu ne pourras pas la réimplémenter dans les classes filles (virtual + template c'est pas possible)

[Bousk]

Je comprends que Addition soit une IOperation, mais en quoi AdditionValue devrait être une Addition ?
La hiérarchie en place me semble mauvaise.
Et le code bien trop court pour comprendre le vrai problème et donc espérer une solution.

[micamused]

Sauf que si tu fais ça, tu ne pourras pas la réimplémenter dans les classes filles (virtual + template c'est pas possible)

Rebonjour, pour cloturer le sujet et surtout donner une solution qui pourrait etre utile a d'autres, effectivement il y avait encore un probleme avec ma solution et il a fallu adapter de cette maniere:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
template<typename Value>
void DoOperation(Value a, Value b) const;
 
/*
    Implementation Addition
*/
 
template <typename Value>
void Addition::DoOperation(Value a, Value b) const
{
    const AdditionValue<Value>* AdditionCPtr = dynamic_cast<const AdditionValue<Value>*>(this);
    SQ_REQUIRE(AdditionCPtr, "bad type");
    return AdditionCPtr->DoOperation(a, b);
}

Donc comme vous pouvez le voir, une maniere de remédier au probleme d'incompatibilité entre virtual et template dont parlait skeud c'est de ne pas déclarer virtuel la fonction dans la classe Operation, mais la définir en forçant le cast et donc l'appel a la fonction de la classe Fille AdditionValue.

On peut clore le sujet avec cette solution?