Comment initialiser la variable membre const dans une classe?
#include <iostream>
using namespace std;
class T1
{
const int t = 100;
public:
T1()
{
cout << "T1 constructor: " << t << endl;
}
};
Lorsque j'essaie d'initialiser la variable membre const t avec 100. Mais cela me donne l'erreur suivante:
test.cpp:21: error: ISO C++ forbids initialization of member ‘t’
test.cpp:21: error: making ‘t’ static
Comment puis-je initialiser une valeur const?
9 réponses
La variable const indique si une variable est modifiable ou non. La valeur constante assignée sera utilisée chaque fois que la variable est référencée. La valeur attribuée ne peut pas être modifiée pendant l'exécution du programme.
L'explication de Bjarne Stroustrup résume brièvement:
Une classe est généralement déclarée dans un fichier d'en-tête et un fichier d'en-tête est généralement inclus dans de nombreuses unités de traduction. Cependant, pour éviter les règles compliquées de l'éditeur de liens, C++ exige que chaque objet a une définition unique. Cette règle serait brisée si C++ autorisait la définition en classe d'entités qui devaient être stockées en mémoire en tant qu'objets.
Une variable const doit être déclarée dans la classe, mais elle ne peut pas y être définie. Nous devons définir la variable const en dehors de la classe.
T1() : t( 100 ){}
Ici, l'affectation t = 100 se produit dans la liste d'initialisation, bien avant l'initialisation de la classe.
Eh Bien, vous pourriez faire static:
static const int t = 100;
, Ou vous pouvez utiliser un initialiseur de membre:
T1() : t(100)
{
// Other constructor stuff here
}
Il existe plusieurs façons d'initialiser les membres const à l'intérieur de la classe..
Définition du membre const en général, nécessite également l'initialisation de la variable..
1) à l'intérieur de la classe, si vous voulez initialiser la const, la syntaxe est comme ceci
static const int a = 10; //at declaration
2) deuxième façon peut être
class A
{
static const int a; //declaration
};
const int A::a = 10; //defining the static member outside the class
3) Eh bien, si vous ne voulez pas initialiser à la déclaration, alors l'autre moyen est de Via constructeur, la variable doit être initialisée dans la liste d'initialisation (pas dans le corps du constructeur). Il doit être comme ça
class A
{
const int b;
A(int c) : b(c) {} //const member initialized in initialization list
};
Vous pouvez mettre à niveau votre compilateur pour prendre en charge C++11 et votre code fonctionnerait parfaitement.
-
Utiliser la liste d'initialisation dans le constructeur.
T1() : t( 100 ) { }
Une Autre solution est
class T1
{
enum
{
t = 100
};
public:
T1();
};
Donc t est initialisé à 100 et il ne peut pas être modifié et il est privé.
Si un membre est un Tableau, il sera un peu complexe que la normale est:
class C
{
static const int ARRAY[10];
public:
C() {}
};
const unsigned int C::ARRAY[10] = {0,1,2,3,4,5,6,7,8,9};
Ou
int* a = new int[N];
// fill a
class C {
const std::vector<int> v;
public:
C():v(a, a+N) {}
};
Si vous ne voulez pas rendre statique le membre de données const dans la classe, vous pouvez initialiser le membre de données const en utilisant le constructeur de la classe.
Par exemple:
class Example{
const int x;
public:
Example(int n);
};
Example::Example(int n):x(n){
}
S'il y a plusieurs const données membres de la classe, vous pouvez utiliser la syntaxe suivante pour initialiser les membres:
Example::Example(int n, int z):x(n),someOtherConstVariable(z){}
Une autre façon possible sont les espaces de noms:
#include <iostream>
namespace mySpace {
static const int T = 100;
}
using namespace std;
class T1
{
public:
T1()
{
cout << "T1 constructor: " << mySpace::T << endl;
}
};
L'inconvénient est que d'autres classes peuvent également utiliser les constantes si elles incluent le fichier d'en-tête.
Vous pouvez ajouter static pour rendre possible l'initialisation de cette variable de membre de classe.
static const int i = 100;
Cependant, ce n'est pas toujours une bonne pratique à utiliser dans la déclaration de classe, car tous les objets instaciés de cette classe partageront la même variable statique qui est stockée dans la mémoire interne en dehors de la mémoire de portée des objets instanciés.