Manipulation d'un nom de template dans une #define-macro

Marsh Posté le 07-09-2008 à 20:33:09

Voila, je voudrais accéder à une variable globale pré-définie (je sais que cette variable existe et suit un certain format). Donc du genre :

Code :

#define GET_TYPE(X) g##X##Type

Maintenant, un peu plus dur, je voudrais utiliser cette macro dans un template

Code :

template<class A, class B>
class MyTemplate {
int getType() { return GET_TYPE(A); }
};

Et là,c'est le drame ... [:chrisbk]

Code :

/tmp/template.hpp:35: error: 'gAType' was not declared in this scope

Reply

Marsh Posté le 07-09-2008 à 20:33:09

Reply

Marsh Posté le 07-09-2008 à 21:06:13

tu veut faire quoi exactement. Parce que la deja v_v macro+globale, ca sent le sapin.
donc donne moi le details de ton truc.

Ton truc marchera jamais anyway

Reply

Marsh Posté le 07-09-2008 à 21:50:59

Par exemple, j'ai un template Model qui prend en parametre (de template) deux classes

Code :

template<class A, class B>
class Model {
A* Create() { new A(); }
};

Je sais que pour toutes classe A, il existe :
- une classe AType
- un unique objet global défini ainsi : Model<A,AType>* gpAModel = new gpAModel<A,AType>();

J'ai ainsi défini :

Code :

#define GET_MODEL(T) g##T##Model<T,T##Type>

Maintenant, je voudrais dans un template de classe MyTemplate accèder à cette variable globale :

Code :

template<class C>
class MyTemplate {
C* Do() {
return GET_MODEL(C)->Create();
}
};

Pour ainsi écrire simplement

Code :

MyTemplate<A> var;
A* pA = var->Do();

Message édité par Olivier51 le 07-09-2008 à 21:51:26

Reply

Marsh Posté le 07-09-2008 à 21:56:58

oui mais non. Un paramètres template n'est aps un token d epreprocessing.
Utilise plutot des traits en faisant une table de correspondance entre ton A et ton Model de A.

Code :

template<class T> struct model;
template<> struct model<A>
{
typedef AType type;
static inline type Get() { return gpAModel; }
};

Surcharge en suite model pour chaque type que tu connais.
Puis pour récupérer le model dans ta classe :

Code :

template<class X> struct myTemplate
{
X* create() { return model<X>::Get()->Create(); }
}

Mais ton schéma est zarb, et les globales c'ets la merde assurée.

C'est une abstract factory que tu veut faire ou bien ?

Message édité par Joel F le 07-09-2008 à 21:57:46

Reply

Marsh Posté le 07-09-2008 à 22:04:32

J'ai fait un peu de refactoring dernierement, et j'ai ainsi déplacer la variable statique dans Model :
Par exemple, j'ai un template Model qui prend en parametre (de template) deux classes

Code :

template<class A, class B>
class Model {
A* Create() { new A(); }
static Model<A,C>* gpModel;
};

+ Spécialization de ce template pour chaque object, ainsi :

Code :

template<>
class Model<A,AType> {
A* Create() { new A(); }
static Model<A,AType>* gpModel;
};
Model<A,AType>* gpModel = new Model<A,AType>();

Je peux ainsi accèder à cette variable globale, en appellant Model<A,AType>::gpModel ... Mais j'ai encore besoin de concaténation pour "créer" le AType à partir de A :

Code :

#define GET_MODEL(T) Model<T,T##Type>::gpModel

Reply

Marsh Posté le 07-09-2008 à 22:07:45

ca reste moche

Message édité par Joel F le 07-09-2008 à 22:08:21

Reply

Marsh Posté le 07-09-2008 à 22:11:30

Oups, je viens de voir ta réponse ... En fait, à la base, je voulais garder un truc générique pour éviter d'obliger à faire un spécialization pour chaque objet ... Mais comme maintenant, j'ai commencé à spécializer autant aller jusqu'au bout ...
Je pense que je vais mixer ta proposition et ma refactoring pour avoir un truc du genre :

Code :

template<class A>
class Model {
A* Create() { new A(); }
size_t TypeSize() { return 0;}
static Model<A>* gpModel;
};
template<>
class Model<A> {
A* Create() { new A(); }
size_t TypeSize() { return size(AType);}
static Model<A>* gpModel;
};
Model<A>* Model<A>::gpModel = new Model<A>();

Reply

Marsh Posté le 07-09-2008 à 22:22:55

ou faire un vrai pattern Factory

Reply

Manipulation d'un nom de template dans une #define-macro

Sujets relatifs:

Leave a Replay