Initialisation de "static const" dans méthode static ?

Version imprimable

Bonjour,

Je développe actuellement un applicatif que je veux configurer à l'aide d'un fichier XML.

En fait j'ai une classe qui ressemble à celle-ci :
Code:

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 class MaClasse { private: static const float MON_FLOAT; public: static const int MON_INT; /** * Constructeur */ MaClasse(); /** * Destructeur */ ~MaClasse(); /** * Initialise les constantes globales des instances de la classe MaClasse. * @param mon_float un flottant * @param mon_int un entier */ static void initMesClasses(const float mon_float, const int mon_int); };
Mon but est d'initialiser MON_INT et MON_FLOAT à l'aide de la méthode static initMesClasses().
J'ai donc tout naturellement tenté une affectation dans cette méthode. Du style :

Code:

MaClasse::MON_INT = mon_int;

Malheureusement cela ne fonctionne pas. :/ En gros le compilo me dit que je ne peux pas modifier la valeur d'un "const". Cela me parait tout à fait logique, hormis le fait que je n'ai jamais initialisé la constante en question...

Donc ma question est : est-ce possible ? Puis-je initialiser mes constantes depuis une methode static ? Si non, quel moyen me permettrait d'initialiser mon appli au début de son exécution (à partir de mon fichier XML) ?

Merci et bonne journée. :]

Salut,

Si ce sont des constantes, il faut que tu initialise les valeurs une bonne fois pour toutes...

cela donnera quelque chose comme:

Code:

1
2
3
4
5
6
7
8
9
10
class MaClass
{
    private:
        static const float monFloat;
    public:
        static const int monInt,
};
/* dans le *.cpp */
const float MaClass::monFloat = 3.1415926;
const int MaClass::monInt=153;

Si tu veux pouvoir modifier les valeurs, tu n'a pas le choix, tu dois utiliser des valeurs non constantes, et, si tu souhaites éviter que "n'importe qui" n'aille les modifier, il faudra fournir un accesseur sur celles-ci.

Cela pourrait prendre la forme de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class MaClass
{
    private:
        friend class reader; // permet à la classe reader uniquement de 
                            // modifier les valeurs ;)
        static float monFloat_;
        static int monInt_,
    public:
        static float monFloat(){return monFloat_;}
        static int monInt(){return monInt_;}
};
/* dans le *.cpp */
/* on fournit des valeur "par défaut", pour le cas où la configuration ne
 * les changerait pas 
 */
float MaClass::monFloat = 3.1415926;
int MaClass::monInt=153;

19/10/2010, 10h55
poliok

Ok c'est noté. Je prendrai donc la seconde solution. C'est dommage, j'espérais en avoir une plus élégante. :/

Merci. :]
19/10/2010, 11h17
koala01

Le fait est que les valeurs constantes sont, par définition, immuables...

Tu ne peux donc décemment pas envisager de déclarer une valeur comme immuable et... vouloir être en mesure de la modifier en même temps :aie: ;)
19/10/2010, 11h47
poliok

Oui je comprends bien... Maintenant j'aurais également compris qu'une constante soit... constante justement... mais après sa première initialisation (parce qu'une constante sans valeur ne sert - a priori - à rien).
19/10/2010, 11h54
koala01

Si ce n'est que tu dois initialiser les constantes au moment de leur définition, vu que tu ne peux plus les modifier une fois qu'elles ont été créés...

Et, comme, de plus, il s'agit de valeur statiques, donc, indépendantes de toute instance de ta classe, elles sont susceptible d'exister alors qu'il n'y a encore aucune instance de ta classe qui a été créée, ce qui fait que tu ne peux de toutes manières pas attendre que l'on passe dans le constructeur pour les initialiser ;)

N'oublie pas qu'une variable statique n'est en définitive qu'une variable globale qui se trouve, simplement, dans une portée particulière (du moins, quand c'est un membre de classe) ;)