Discussion :

[xterminhate]

J'ai une collection de classes, qui doivent toutes fournir une fonction membre statique retournant un pointeur vers une chaine de caractère. Je souhaiterais factoriser au maximum mon code.

Voici mon approche sachant que ca coince à la compilation.

Je fais un modèle qui prend en argument la chaine de caractère et qui implémente la fonction statique :

Code :

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

1
2
3
4
5
template< char const * str>
struct Base
{
  inline static char const * affiche() { return str; }
};

Ensuite, je fais hériter toutes mes classes de ce modele en le spécialisant :

Code :

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

1
2
3
4
struct A : Base<"A"> { /**/ };
struct B : Base<"B"> { /**/ };
struct C : Base<"C"> { /**/ };
struct D : Base<"D"> { /**/ };

Le compilateur ne semble pas apprécier l'instanciation du modele. J'ai tenté de contourner le probleme en stockant la chaine dans une variable char const * intérmédiaire mais sans plus de succès car d'autres erreurs apparaissent.

Toutes suggestions sont les bienvenues. Ma conception object n'est peut etre pas optimale au dela du probleme de syntaxe.

Xter.

[Médinoc]

Euh... Je connais mal le C++, mais je ne suis pas certain que les templates acceptent une paramètre pointeur...

Pourquoi ne pas utiliser simplement des macros comme le fait MFC ?

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#define BEGIN_STRUCT(name) struct name {\
inline static char const * affiche() { return #name; }\
#define END_STRUCT };
 
BEGIN_STRUCT(A)
	//...
END_STRUCT
 
BEGIN_STRUCT(B)
	//...
END_STRUCT

Et encore, tu n'es pas obligé de mettre le end, tu peux juste mettre };
Ou encore, tu peux toujours mettre juste la fonction dans la macro, et appeler la macro depuis l'intérieur des accolades...

[bolhrak]

Effectivement les templates ne prennent que des types ou des constantes entières en paramètres, donc ça en peut pas marcher.

Voilà une solution fonctionnant avec les templates, basée sur le CRTP et un peu plus propre (à mon goût) que les macros :

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
 
 
template <class Derived> struct Base {
 
    inline static char const* affiche() {return Derived::name;}
 
};
 
struct A : public Base<A> {
 
    private:
        static const char* name;
 
        friend class Base<A>;
 
};
 
//ne pas oublier de définir la variable dans le .cpp

[Jean-Marc.Bourguet]

On peut avoir des paramètres templates qui sont des objets, mais il faut qu'ils aient un linkage externe.

Code :

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

1
2
3
4
5
6
7
8
9
template< char const * str>
struct Base
{
  inline static char const * affiche() { return str; }
};
 
extern char const Aname[]="A";
 
struct A : Base<Aname> {};

Il faut le extern pour éviter que Aname ait un linkage interne.

[bolhrak]

Merci de l'information

[xterminhate]

Tout type intégral (et leur pointeur) est accepté en paramètre d'un modele !

Jean-Marc, merci pour cette réponse rapide. J'avais tenté un static en préfixe sans succès sentant bien que le problème venait de ce que tu as expliqué. J'ai confondu avec extern que je n'ai plus utilisé depuis longtemps !!!

Xter.

[xterminhate]

Médinoc, ta proposition de macro répondrait également à mon besoin. En mettant de coté le débat sur les avantages et les inconvénients de la macro par rapport au modele, j'évite les macros dans mon code à cause de l'ami doxygen qui ne les analyse pas (donc pas de documentation sur les membres générées par les macros) !

Xter.