variable membre initialisable mais non modifiable

Ben wrote:

Est-il possible en C++ d'initialiser une variable membre a la construction
de l'objet, mais d'interdire toute modification futur de cette variable par
les fonctions membres. (un genre de variable constante mais initialisable a
la construction de l'objet)?

declarer le membre const et utiliser les initializer list du constructeur et
faire attention a l'ordre de declaration des membres (et pas de leur apparition
dans la liste).

a+, ld.

--
[ Laurent Deniau -- Scientific Computing & Data Analysis ]
[ CERN -- European Center for Nuclear Research ]
[ Laurent.Deniau@cern.ch - http://cern.ch/Laurent.Deniau ]
[ -- One becomes old when dreams become regrets -- ]

Est-il possible en C++ d'initialiser une variable membre a la construction
de l'objet, mais d'interdire toute modification futur de cette variable
par les fonctions membres. (un genre de variable constante mais
initialisable a la construction de l'objet)?

Oui :

class Objet
{
public:

Objet(const int var)
: m_variable(var)
{
}

private:

const int m_variable;
};

Vincent

--
SL> Au fait elle est mieux ma signature maintenant ?
Oui. T'enlève encore les conneries que t'as écrit dedans et c'est bon.
-+- JB in <http://www.le-gnu.net> : Le neuneuttoyage par le vide -+-

"Ben" <serbenet@free.fr> a écrit dans le message de
news:3f58abec$0$16515$626a54ce@news.free.fr...

Est-il possible en C++ d'initialiser une variable membre a la construction
de l'objet, mais d'interdire toute modification futur de cette variable
par

les fonctions membres. (un genre de variable constante mais initialisable
a

la construction de l'objet)?

Il suffit de la déclarer const :

class x
{
const int y;

public:
x( int z ) : y( z ) {}
};

Chris

Ben wrote:

Est-il possible en C++ d'initialiser une variable membre a la
construction de l'objet, mais d'interdire toute modification futur de
cette variable par les fonctions membres. (un genre de variable
constante mais initialisable a la construction de l'objet)?

Je ne pense pas que ce soit possible directement, avec un type POD.
Cependant, si tu fais une classe qui garde ta valeur, tu pourras y arriver
(avec un template, ça tourne tout seul). Voici un exemple :

template <class T> ProtegeValeur
{
public:
ProtegeValeur (const T& val)
: mVal (val) {}

const T& GetValue () {return mVal;}

// ou aussi :
const T& operator () () {return mVal;}

private:
T mVal;
};

Ainsi, dans ta classe, si tu veux un int seulement initialisable dans le
constructeur tu fais :

class Demo
{
public:
Demo ()
{
mMonInt = ProtegeValeur<int> (4);
}

private:
ProtegeValeur<int> mMonInt;
};

Et le tour est joué. Oui, c'est vrai, il faut ensuite assumer que mMonInt ne
sera pas à son tour changé de valeur, mais c'est quand même beaucoup moins
probable puisqu'il faut une syntaxe assez lourde pour lui assigner une
nouvelle valeur.

Si ca reste un problème, tu assignes la valeur à ProtegeValeur seulement par
une Init (et pas par le constructeur), qui lance une exception (ou retourne
simplement) si une valeur a déjà été assignée et qu'on tente de réappeler
Init(). Cette deuxième solution semble plus répondre à ton attente.
--
<=- Michaël "Cortex" Monerau -=>

Michaël Monerau wrote:
<snip>

Ma réponse s'applique bien sûr si ta valeur ne peut pas être déterminée au
moment de la liste d'initialisation :) Sinon, utilise bien sûr la liste
d'initialisation plutôt que de passer par ma solution template (comme
Laruent, Vincent et Christophe t'ont suggéré) ;) C'est un peu le marteau
pour la mouche !
--
<=- Michaël "Cortex" Monerau -=>