Как инициализировать переменную const member в классе?

#include <iostream>

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

  T1()
  {

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

Когда я пытаюсь инициализировать переменную const member t со 100. Но это дает мне следующую ошибку:

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

Как я могу инициализировать значение const?

Ответ 1

Переменная const указывает, является ли переменная изменчивой или нет. Приведенная константа будет использоваться каждый раз, когда будет указана переменная. Назначенное значение не может быть изменено во время выполнения программы.

Bjarne Stroustrup пояснение кратко подводит итог:

Класс обычно объявляется в файле заголовка, и заголовочный файл обычно включается во многие единицы перевода. Однако, чтобы избежать сложных правил компоновщика, С++ требует, чтобы каждый объект имел уникальное определение. Это правило будет нарушено, если С++ допускает определение класса в классе, которое должно храниться в памяти как объекты.

A const переменная должна быть объявлена внутри класса, но она не может быть определена в ней. Нам нужно определить переменную const вне класса.

T1() : t( 100 ){}

Здесь назначение t = 100 происходит в списке инициализаторов, намного до начала инициализации класса.

Ответ 2

Ну, вы можете сделать это static:

static const int t = 100;

или вы можете использовать инициализатор элемента:

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

Ответ 3

Существует несколько способов инициализации элементов const внутри класса.

Определение элемента const в общем случае также требует инициализации переменной.

1) Внутри класса, если вы хотите инициализировать const, синтаксис подобен этому

static const int a = 10; //at declaration

2) Второй способ может быть

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

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

3) Ну, если вы не хотите инициализировать при объявлении, то другой путь - через конструктор, переменная должна быть инициализирована в списке инициализации (не в теле конструктора). Это должно быть так.

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

Ответ 4

Вы можете обновить свой компилятор для поддержки С++ 11, и ваш код будет работать отлично.
Используйте список инициализации в конструкторе.
```
T1() : t( 100 )
{
}
```

Ответ 5

Другим решением является

class T1
{
    enum
    {
        t = 100
    };

    public:
    T1();
};

Итак, t инициализируется до 100, и его нельзя изменить, и он является закрытым.

Ответ 6

Если элемент является массивом, он будет немного сложнее, чем нормальный:

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

или

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

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

Ответ 7

Другим возможным способом являются пространства имен:

#include <iostream>

namespace mySpace {
   static const int T = 100; 
}

using namespace std;

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

Недостатком является то, что другие классы также могут использовать константы, если они включают заголовочный файл.

Ответ 8

Если вы не хотите, чтобы член данных const в статическом классе, вы можете инициализировать элемент данных const, используя конструктор класса. Например:

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

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

Если в классе есть несколько членов данных const, вы можете использовать следующий синтаксис для инициализации членов:

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

Ответ 9

вы можете добавить static, чтобы сделать возможной инициализацию этой переменной-члена класса.

static const int i = 100;

Однако это не всегда хорошая практика для использования объявления внутри класса, потому что все объекты, созданные из этого класса, будут иметь одну и ту же статическую переменную, которая хранится во внутренней памяти за пределами области памяти экземпляров объектов.