Come inizializzare la variabile membro const in una classe?

#include <iostream>

using namespace std;
class T1
{
  const int t = 100;
  public:

  T1()
  {

    cout << "T1 constructor: " << t << endl;
  }
};

Quando cerco di inizializzare la variabile membro const tcon 100. Ma mi dà il seguente errore:

test.cpp:21: error: ISO C++ forbids initialization of member ‘t’
test.cpp:21: error: making ‘t’ static

Come posso inizializzare un constvalore?

La constvariabile specifica se una variabile è modificabile o meno. Il valore della costante assegnato verrà utilizzato ogni volta che si fa riferimento alla variabile. Il valore assegnato non può essere modificato durante l'esecuzione del programma.

La spiegazione di Bjarne Stroustrup lo riassume brevemente:

Una classe è tipicamente dichiarata in un file di intestazione e un file di intestazione è tipicamente incluso in molte unità di traduzione. Tuttavia, per evitare complicate regole del linker, C ++ richiede che ogni oggetto abbia una definizione univoca. Questa regola sarebbe infranta se C ++ consentisse la definizione in classe di entità che dovevano essere archiviate in memoria come oggetti.

Una constvariabile deve essere dichiarata all'interno della classe, ma non può essere definita in essa. Dobbiamo definire la variabile const al di fuori della classe.

T1() : t( 100 ){}

Qui l'assegnazione t = 100avviene nell'elenco degli inizializzatori, molto prima che avvenga l'inizializzazione della classe.

Bene, potresti farlo static:

static const int t = 100;

oppure puoi usare un inizializzatore di membri:

T1() : t(100)
{
    // Other constructor stuff here
}

Esistono due modi per inizializzare i membri const all'interno della classe ..

La definizione di membro const in generale, richiede anche l'inizializzazione della variabile.

1) All'interno della classe, se vuoi inizializzare il const la sintassi è così

static const int a = 10; //at declaration

2) Il secondo modo può essere

class A
{
  static const int a; //declaration
};

const int A::a = 10; //defining the static member outside the class

3) Bene, se non si desidera inizializzare alla dichiarazione, l'altro modo è tramite il costruttore, la variabile deve essere inizializzata nell'elenco di inizializzazione (non nel corpo del costruttore). Deve essere così

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

Se non si desidera rendere conststatico il membro dati nella classe, è possibile inizializzare il constmembro dati utilizzando il costruttore della classe. Per esempio:

class Example{
      const int x;
    public:
      Example(int n);
};

Example::Example(int n):x(n){
}

se constnella classe sono presenti più membri dati, è possibile utilizzare la seguente sintassi per inizializzare i membri:

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

1. Puoi aggiornare il tuo compilatore per supportare C ++ 11 e il tuo codice funzionerà perfettamente.

2. Usa l'elenco di inizializzazione nel costruttore.

   T1() : t( 100 )
   {
   }

Un'altra soluzione è

class T1
{
    enum
    {
        t = 100
    };

    public:
    T1();
};

Quindi t è inizializzato a 100 e non può essere modificato ed è privato.

Se un membro è un array, sarà un po 'complesso rispetto al 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};

o

int* a = new int[N];
// fill a

class C {
  const std::vector<int> v;
public:
  C():v(a, a+N) {}
};

Un altro modo possibile sono gli spazi dei nomi:

#include <iostream>

namespace mySpace {
   static const int T = 100; 
}

using namespace std;

class T1
{
   public:
   T1()
   {
       cout << "T1 constructor: " << mySpace::T << endl;
   }
};

Lo svantaggio è che anche altre classi possono utilizzare le costanti se includono il file di intestazione.

Questo è il modo giusto per farlo. Puoi provare questo codice.

#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;
}

se stai usando, C++10 Compiler or belownon puoi inizializzare il membro contro al momento della dichiarazione. Quindi qui è necessario creare un costruttore per inizializzare il membro dati const. È inoltre necessario utilizzare l'elenco degli inizializzatori T1():t(100)per ottenere memoria all'istante.

è possibile aggiungere staticper rendere possibile l'inizializzazione di questa variabile membro di classe.

static const int i = 100;

Tuttavia, non è sempre una buona pratica usare la dichiarazione di classe interna, perché tutti gli oggetti istanziati da quella classe condivideranno la stessa variabile statica che è archiviata nella memoria interna al di fuori della memoria dell'ambito degli oggetti istanziati.