Gestionnaire/Manager de Variables/Constantes

Bonjour,

J'aimerai avoir vos avis et vos conseils au sujet de la méthode pour réaliser un gestionnaire (ou manager) de constantes (mais aussi de variables, ça change pas grand chose) pour mes projets C++.

Le but d'un manager de ce type est tout simplement de centraliser toutes les "valeurs fixes" que l'on pourrait trouver éparpillées dans le code. Pour ma part, mes projets étant généralement des jeux, il pourrait s'agir de variables/constantes genre "vitesse_vaisseau", "dommages_pistolet", etc...

Ca fait plusieurs fois que j'essaye de réaliser quelque chose de la sorte, mais je ne trouve pas de solution qui me convienne réellement. J'ai eu beau chercher avant sur le net, je n'ai pas trouvé de solution satisfaisante.

Alors voila, pour ma part, 2 solutions me viennent à l'esprit, mais j'imagine qu'il y a sans doute bcp d'autres qui sont bien mieux, et j'aimerai justement votre avis à ce sujet.

Solution 1 :
Déclarer carrément des variables ou constantes dans un header, comme des variables classiques (oui c'est moche ^^)...

Avantages :
- pas d'espace mémoire perdu
- pas de pertes de perf à l'exécution

Désavantages :
- c'est moche ^^
- dès que je veux rajouter une variable, je dois recompiler TOUT les cpp qui utilise une des variables, ce qui est très chiant.
- pas du tout dynamique : vu que les noms des variables ne sont pas des string, je ne peux pas charger leurs valeurs depuis un fichier de config à l'exécution par exemple.


Solution 2 :
Utiliser une std::map pour lier un string (nom de la variable) avec sa valeur. Les variables de "valeur" serait une union entre les différents types de données que je veux pouvoir enregistrer.

Avantages :
- ça me parait être une solution "élégante"
- c'est dynamique : je peux accéder/ajouter/modifier des variables à l'exécution

Désavantages :
- Perte d'espace mémoire dû à la présence de l'union, surtout si l'on veut stocker des choses comme des vecteurs de 3 floats...
- Il faut connaître le type de la donnée pour accéder à sa valeur.
- J'ai peur que au niveau performance, une std::map ça soit pas top, car devoir accéder des dizaines et dizaines de fois par frame à une std::map...

Mes inquiétudes sur les perf et perte d'espace mémoire de la solution 2 sont surtout du au fait que je travaille actuellement sur plateforme portable (nintendo ds), et que j'aimerai une solution qui ne surcharge pas trop le processeur rikiki de la bestiole, ainsi que sa RAM ridicule.


Merci d'avance pour votre aide, vos avis / remarques / conseils / insultes ^^

Yagero

J'ai été aussi confronté à cette problématique et j'ai choisi l'option 1

Par contre, ce que tu appelles l'aspect dynamique, je l'ai quand même car mes variables possèdent comme attribut optionnel, une valeur par défaut (en dur), un nom de clé de registre, un nom de tag xml dans un fichier xml.

Ainsi, lors de la première lecture de la valeur, la valeur par défaut est assignée puis si il y a un nom de clé de registre, on lit cette clé et on assigne la valeur lue à la variable et enfin, s'il y a un tag xml, on le lit et on assigne la valeur lue à la variable.

C'est vrai que cela oblige une recompilation à chaque modification.

Citation:

---

Envoyé par yagero

J'aimerai avoir vos avis et vos conseils au sujet de la méthode pour réaliser un gestionnaire (ou manager) de constantes (mais aussi de variables, ça change pas grand chose) pour mes projets C++.

---

A mon avis ça change beaucoup justement. Si tu n'as que des constantes, tu peux très bien avoir un header qui les contient toutes, ou bien les séparer en plusieurs headers si tu peux faire une séparation logique. Certains vont crier au scandale, mais à mon avis "s'authoriser" à faire ça c'est utiliser toutes les possibilités du C++ (va poser la même question sur le forum Java, certains vont te proposer de faire un Singleton d'une classe ConstManager avec une méthode get pour chaque constante :aie: :mouarf: ).

Par contre, si tu as des variables ça change beaucoup, parce que des variables globales c'est très dangereux, sachant que depuis n'importe où dans ton code tu peux les modifier, tu risques de faire des erreurs ou d'avoir des bugs. Ca peut carrément être la catastrophe si tu as du multi-thread (je ne connais pas le développement Nintendo DS donc je sais pas si c'est possible), là tu serais obligé de synchroniser l'accès aux variables. Donc ta solution 1 ne me semble pas adaptée, quand à la deuxième solution, si j'ai bien compris, elle t'obligerait à avoir ta std::map en global, donc retour à la case départ (tu ne ferais qu'alourdir la solution 1, donc ce serait encore moins "élégant").

Ton problème vient peut-être de la conception de tes classes. Si tu veux faire les choses "proprement" orienté objet, chaque variable devrait être stocké dans l'objet concerné (e.g. vitesse_vaisseau serait dans une classe Vaisseau), et quand sa valeur change l'objet serait responsable d'envoyer un message à chaque objet qui en aurait besoin, ou alors les objets iraient automatiquement chercher la valeur à chaque fois qu'ils en ont besoin pour un calcul (c.f. le modèle MVC).

Salut,

Pourquoi ne pas, bêtement, déclarer les constantes sous la forme de variables statiques (... constantes) des classes auxquelles elles se rapporte (éventuellement en accessibilité publique) :question::

• vitesse_vaisseau est une variable se rapporte à... un vaisseau
• force_pistolet est une variable qui se rapporte à... un pistolet
• ...

En déclarant ta variable statique, tu en fais une... variable de classe, c'est à dire une variable qui ne dépend d'aucune instance propre de la classe en question, tout en gardant la relation "forte" d'appartenance de la variable à la classe...(une sorte de "variable globale" mais qui reste intrinsèquement liée à la classe)

Merci pour vos réponses très intéressantes.

Le problème que je vois apparaître en faisant des variables statiques de classes, c'est que du coup, rien n'est centralisé.

C'est à dire que si je veux charger les valeurs des variables à partir d'un fichier de config externe à l'exécution, c'est pas vraiment faisable, je dois aller chercher manuellement toutes les variables à droite et à gauche... Alors qu'avec une std::map<string, value>, une boucle et le tour est joué.

De plus, "l'objectif ultime" serait de pouvoir faire une console où je peux modifier toutes les valeurs pendant l'exécution (bon c'est pas vraiment réalisable pour mon projet DS, mais disons pour des projets PC...). Un truc un peu du genre la console de jeux comme HL/HL², où on peut taper les noms de pleins de variables, accéder à leurs valeurs et même les modifier si on est en mode dev.

Ce qu'il faut plutôt faire alors, c'est partir sur un concept proche de la "facade"...

Les variables doivent restées intrinsèquement dépendantes des classes auxquelles elles se rapportent (des classes, hein, pas des objets ;)), mais tu crées une facade qui te permet d'aller manipuler de manière "indirecte" ces différentes variables ;)) (bien que tu auras un problème si tu espère pouvoir modifier une constante :P)

J'ai appris, et vu aussi que les langages de scripts sont très efficace pour ce genre de truc.
Toute variable globales peut être modifier par un script , et ces variables sont lu en temps réel par le moteur C++.
Les compagnies de jeux semblent s'interessés au python pour cela.
Un prof la fait en ruby ( car il connaissait et il aime bien )
Mais je ne sais pas si cela correspond exactement à ce dont tu as besoin, de plus je ne sais pas trop l'implémenter. ( Si quelqu'un a de la doc ).

Du coup le script permet de modifier les variables dans un endroit centralisé, je pense que le code C++ garde sa propreté, et puis tu peux faire du changement en temps réel.

( En espérant ne pas être hors sujet )