Discussion :

[anykeyh]

Bonsoir à tous et toutes!

Suite à quelques idée, je souhaiterais effectuer une opération qui n'est pas par defaut autorisé par le c++, à savoir l'initialisation des structures statiques au prototypage...

Exemple de ce qu'il faut normalement faire:

Code :

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

1
2
3
4
5
6
7
8
9
10
 
class A {
private:
   struct Test {
   }
public:
   static Test myTest;
}
 
Test A::myTest; //Déclaration

(et la nous entrons dans la partie un peu plus "sale"):
Les structures vide comme celle la permettent d'executer du code à l'initialisation du programme, comme par exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class A {
private:
   struct Test {
        Test() {
            printf("S'executera avant la premiere ligne du main()");
        }
   };
public:
   static Test myTest;
};
 
A::Test A::myTest; //Déclaration

En évitant de parler de l'aspect "sale" du code (j'en suis parfaitement conscient, mais c'est une nécessité dans l'application que je souhaite developper), je souhaiterais pouvoir faire la même chose en déclarant directement et initialisant directement ma structure statique. Au départ j'étais parti sur un template:

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<typename T>
class _initializer {
  static T reference; //Objet à initialiser
}
 
template<typename T>
T _initializer<T>::reference; //Déclaration de l'objet statique
 
class A {
private: 
struct Test {
 Test() {
 }
};
public:
    typedef _initializer<Test>::reference _declarerPourInitialiser; //?
};

Bien évidement, ce genre de code ne fonctionne pas, l'objet s'initialisant uniquement si le typedef est utilisé au moins une fois dans le code de l'application.
Or justement ces objets, l'utilisateur ne doit pas devoir les utiliser, ils existent uniquement pour forcer le compilo à executer du code avant le main()

Quelqu'un aurait-il une idée (me suis-je bien fait comprendre au moins? )

Je repete que oui ce code est sale (pas besoin de me le dire!), et que non je ne peu pas declarer hors de ma classe quoi que ce soit

[Luc Hermitte]

Pourquoi tu ne définis pas une simple variable globale limitée à ton unité de traduction ?
Pas besoin de partir sur des trucs compliqués.

PS: n'oublie pas que tu n'as aucun moyen d'assurer des dépendances entre ces données statiques ("statique" comme dans "static storage").

[anykeyh]

Justement:

Je vais expliquer mon cas plus en detail:

Je souhaite faire une macro qui me permet de declarer un champ de la sorte:

Code :

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

#define CHAMP(Nom, Type) private: Type Nom;

Mais qui en plus déclare une structure privée (que l'utilisateur n'utilisera pas) mais qui me permet d'ajouter le champ à un tableau de champ:

Code :

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

1
2
3
4
5
6
7
#define CHAMP(Nom, Type) private: Type Nom; \
                                               static struct _field_init_##Nom { \
                                                     _field_init_##Nom() { \
                                                            printf("Ajout de %s", #Nom); \
                                                            FieldManager::GetInstance()->Ajouter(#Nom, &Class::Nom); \
                                                     } \
                                               }; \

De ce fait, je souhaite par tout les moyens forcer l'initialisation au prototypage par une méthode la plus sale soit elle, afin que l'utilisateur n'est pas à déclarer une macro par champ en plus et ce hors de la classe...

[Feriaman]

Salut,

Désolé, je ne sais pas répondre à ta question.

En revanche, ton dernier post me fait penser à des choses dans lesquelles j'ai déjà baigné. Il est possible que ce soit juste dans ma tête, car tu ne donnes pas tellement d'infos sur ce que tu souhaite faire.

Quoi qu'il en soit, est-ce que la génération de code ne serait pas une forme de solution à tes problèmes ?

Une moulinette qui transformerait :

Code :

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

1
2
3
4
5
6
TropLaClasse FooBar
[
protected :
	int foo;
	std::string bar;
]

en

Code :

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

1
2
3
4
5
6
7
8
Class FooBar_Generated_Do_Not_Touch
{
public :
	FooBar_Generated_Do_Not_Touch();
protected :
	int foo;
	std::string bar;
}

et

Code :

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

1
2
3
Class FooBar : public FooBar_Generated_Do_Not_Touch
{
}

et

Code :

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

1
2
3
4
5
6
 
MonGrosTableauDeChamps::MonGrosTableauDeChamps()
{
	unChamp["FooBar"]["foo"] = "int";
	unChamp["FooBar"]["bar"] = "std::string";
}

[EDIT]Je viens de rééditer la plus grosse partie du code, ça ne voulait rien dire avant... je vais ptet aller boire un café moi.
[/EDIT]

[anykeyh]

Effectivement en realité je souhaite developper un moteur de reflection (comme les langages managé) en c++

Et ce probleme semble etre le seul que je ne puisse résoudre

[Feriaman]

Woaw.

Et bien désolé de ne pas être plus utile.
Et courage ! Ce n'est pas un problème simple auquel tu t'attaques.

Pour ma part, je crois que quitte à forcer l'utilisateur à utiliser ce genre de syntaxe :

Code :

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

CHAMP(int,toto)

plutôt que :

Code :

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

int toto;

Autant lui proposer carrément un autre langage ou méta-langage qui, pourquoi pas, ressemblerait à du C++ et serait "compilé" en C++ (qu'il faudrait compiler à son tour).

Reste que parser du C++, c'est touchy.

En tout cas : bonne chance.

[Luc Hermitte]

Passer un préprocesseur (qui te génère ce que tu cherches) me paraitrait moins lourd.

[loufoque]

Je n'ai jamais compris l'intérêt de la réflection à l'exécution.
C'est tellement plus utile à la compilation, et tellement moins intrusif...

[Feriaman]

Je n'ai jamais compris l'intérêt de la réflection à l'exécution.
C'est tellement plus utile à la compilation, et tellement moins intrusif...

Je crois que tu ouvres un autre débat.

[anykeyh]

Hop, je prend note de vos remarques => Est-ce possible d'integrer une moulinette au niveau de gcc juste avant le preprocessing?
Je veux dire sans mouliner les fichiers mais directement les flux?

Car si je dois mouliner les fichiers sa demande à enregistrer une seconde version du fichier cpp/h à chaque compilation... :-/

[Alp]

Passer un préprocesseur (qui te génère ce que tu cherches) me paraitrait moins lourd.

Tout à fait d'accord. Et dans ce cas il faut mouliner chacun de tes fichiers... (facilité grâce aux makefiles)

Je n'ai jamais compris l'intérêt de la réflection à l'exécution.
C'est tellement plus utile à la compilation, et tellement moins intrusif...

Tout à fait.

On en avait déjà parlé ici avec loufoque : Boost.MPL couplé à une profonde compréhension de son mécanisme permettent d'aller très très loin.

Une recherche sur le mot clé "réflexion" en rajoutant peut-être "MPL" devrait t'amener à de telles discussions.