c++ - significa - readonly c#

¿Cómo inicializar la variable miembro de const en una clase?

Question

#include <iostream>
using namespace std;
class T1
{
const int t = 100;
public:
T1()
{
cout << "T1 constructor: " << t << endl;
}
};

Cuando intento inicializar la variable t miembro const con 100. Pero me da el siguiente error:

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

¿Cómo puedo inicializar un valor de const ?

Answer 1

1. Puede actualizar su compilador para que sea compatible con C ++ 11 y su código funcionaría perfectamente.

2. Use la lista de inicialización en el constructor.

   T1() : t( 100 )
   {
   }

Answer 2

Bueno, podrías hacerlo static :

static const int t = 100;

o puede usar un inicializador de miembro:

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

Answer 3

Hay algunas maneras de inicializar los miembros de la clase dentro de la clase.

La definición de miembro const en general, también necesita la inicialización de la variable.

1) Dentro de la clase, si quieres inicializar la const la sintaxis es como esta

static const int a = 10; //at declaration

2) La segunda forma puede ser

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

3) Bueno, si no quieres inicializar en la declaración, entonces la otra forma es a través del constructor, la variable necesita ser inicializada en la lista de inicialización (no en el cuerpo del constructor). Tiene que ser así

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

Answer 4

La variable const especifica si una variable es modificable o no. El valor constante asignado se usará cada vez que se haga referencia a la variable. El valor asignado no se puede modificar durante la ejecución del programa.

La explanation Bjarne Stroustrup lo resume brevemente:

Por lo general, una clase se declara en un archivo de cabecera y, por lo general, un archivo de cabecera se incluye en muchas unidades de traducción. Sin embargo, para evitar reglas de enlazador complicadas, C ++ requiere que cada objeto tenga una definición única. Esa regla se rompería si C ++ permitiera la definición dentro de la clase de las entidades que debían almacenarse en la memoria como objetos.

Una variable const debe declararse dentro de la clase, pero no puede definirse en ella. Necesitamos definir la variable const fuera de la clase.

T1() : t( 100 ){}

Aquí la asignación t = 100 ocurre en la lista de inicializadores, mucho antes de que se produzca la inicialización de la clase.

Answer 5

Otra posible forma son los espacios de nombres:

#include <iostream>
namespace mySpace {
static const int T = 100;
}
using namespace std;
class T1
{
public:
T1()
{
cout << "T1 constructor: " << mySpace::T << endl;
}
};

La desventaja es que otras clases también pueden usar las constantes si incluyen el archivo de encabezado.

Answer 6

Otra solución es

class T1
{
enum
{
t = 100
};
public:
T1();
};

Entonces t se inicializa a 100 y no se puede cambiar y es privado.

Answer 7

Si no desea que el miembro de datos const en la clase sea estático, puede inicializar el miembro de datos const utilizando el constructor de la clase. Por ejemplo:

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

Si hay varios miembros de datos const en clase, puede usar la siguiente sintaxis para inicializar los miembros:

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

Answer 8

Si un miembro es una matriz, será un poco complejo de lo normal:

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

Answer 9

puede agregar static para hacer posible la inicialización de esta variable miembro de clase.

static const int i = 100;

Sin embargo, esta no siempre es una buena práctica para usar la declaración de clase interna, ya que todos los objetos instalados de esa clase compartirán la misma variable estática que se almacena en la memoria interna fuera de la memoria de alcance de los objetos instanciados.