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 tavec 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 constvaleur?

La constvariable spécifie si une variable est modifiable ou non. La valeur constante attribué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 le 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 ait une définition unique. Cette règle serait rompue si C ++ autorisait la définition en classe d'entités qui devaient être stockées en mémoire en tant qu'objets.

Une constvariable 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 = 100se produit dans la liste d'initialisation, bien avant l'initialisation de la classe.

Eh bien, vous pourriez le 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 le const, la syntaxe est comme ceci

static const int a = 10; //at declaration

2) La 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 façon est de passer par le constructeur, la variable doit être initialisée dans la liste d'initialisation (pas dans le corps du constructeur). Ça doit être comme ça

class A
{
  const int b;
  A(int c) : b(c) {} //const member initialized in initialization list
};

Si vous ne souhaitez pas rendre le constmembre de données dans la classe statique, vous pouvez initialiser le constmembre de données à l'aide du 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 constmembres de données dans la classe, vous pouvez utiliser la syntaxe suivante pour initialiser les membres:

Example::Example(int n, int z):x(n),someOtherConstVariable(z){}

1. Vous pouvez mettre à niveau votre compilateur pour prendre en charge C ++ 11 et votre code fonctionnerait parfaitement.

2. Utilisez 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 changé et il est privé.

Si un membre est un tableau, ce sera un peu plus complexe que la normale:

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) {}
};

Les espaces de noms sont un autre moyen possible:

#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.

C'est la bonne façon de faire. Vous pouvez essayer ce code.

#include <iostream>

using namespace std;

class T1 {
    const int t;

    public:
        T1():t(100) {
            cout << "T1 constructor: " << t << endl;
        }
};

int main() {
    T1 obj;
    return 0;
}

si vous utilisez C++10 Compiler or belowalors vous ne pouvez pas initialiser le membre contre au moment de la déclaration. Donc ici, il faut faire constructeur pour initialiser le membre de données const. Il est également indispensable d'utiliser la liste d'initialisation T1():t(100)pour obtenir de la mémoire à l'instant.

vous pouvez ajouter staticpour rendre possible l'initialisation de cette variable membre de classe.

static const int i = 100;

Cependant, ce n'est pas toujours une bonne pratique d'utiliser la déclaration de classe interne, car tous les objets instaciés à partir 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.