Comment initialiser const membre de la variable 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 const variable membre t avec 100. Mais il 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 un const valeur?

avec c++11, c'est possible de vérifier ce lien stackoverflow.com/questions/13662441/...

InformationsquelleAutor Chaitanya | 2013-01-24

c++const

104

La const variable indique si une variable est modifiable ou non. La valeur de la constante attribué sera utilisé chaque fois que la variable est référencée. La valeur attribuée ne peut pas être modifié pendant l'exécution du programme.

Bjarne Stroustrup est explication 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 compliqué linker règles, C++ exige que chaque objet a une définition unique. Cette règle serait brisé si C++ admis dans la définition de la classe d'entités qui doivent être stockées dans la mémoire comme des objets.

Un const variable doit être déclarée dans la classe, mais il ne peut pas être défini. Il nous faut définir la variable const en dehors de la classe.
```
T1() : t( 100 ){}
```
Ici l'affectation t = 100 qui se passe dans la liste des initialiseurs, bien avant la classe initilization se produit.
- Pouvez-vous être un peu élaborée sur la dernière déclaration Here the i = 10 assignment in initializer list happens much before the class initilizaiton occurs. je force l'obtenir. Et, fondamentalement, ce genre de permettre à des définitions dans la classe, le compilateur droit spécifique ?
- Ce que j' = 10 affectation?
- J'ai constantes dans ma classe que je l'initialisation de la façon décrite ci-dessus. Cependant, lorsque j'essaye de créer un objet de cette classe, il me donne un message d'erreur indiquant que operator = function not found dans VC++. Quel peut être le problème?
- Lorsque vous utilisez quelqu'un exact de mots sans attribution, ça s'appelle du plagiat. Veuillez utiliser la bonne attribution - voir stroustrup.com/bs_faq2.html#in-class et stackoverflow.com/questions/13662441/...
- Ouais, j'ai aussi totalement ne comprends pas le code de la réponse - ce que l'enfer est-ce? Peut-il être placé dans un fichier cpp mise en œuvre?
- Belle explication. Mais il pourrait être intéressant d'ajouter que seuls les static const int sont autorisés à être initialisé à l'intérieur de déclaration de classe.
- Je l'aurais utilisé une formulation différente: "const indique si une variable est en lecture seule" ou que "const indique météo d'une variable est modifiable par le code ou pas". Pensez à "const volatile int myVar" qui indique que vous pouvez lire à partir de myVar mais myVar peut changer.
- Bonne réponse, mais ce serait une meilleure réponse si vous le montré a montré l'ensemble de la classe bien définie, même si c'est indiqué dans la question, pour éviter toute confusion, le défilement, les erreurs d'interprétation, etc...
InformationsquelleAutor Dinkar Thakur
45

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
}
```
- Pour son utilisation (et/ou intentions), il serait beaucoup mieux pour le rendre statique.
- Vous avez probablement raison.
- Est-ce à l'instar de certains g++ versions ne permettent pas ce genre d'initialisations ? ou Il n'est pas permis à tous ?
- C++11 Non-membre statique d'initialiseurs de la mise en œuvre de gcc 4.7.
- pourquoi beaucoup mieux? il pourrait être sur l'exigence, si const member doit être accessible de l'fonctions/objets alors pourquoi statique?
- Bien que généralement il est trompeur de donner un exemple pour les débutants de la statique. Car, ils ne savent pas, c'est le seul pour toutes les instances (objets) de cette classe.
- Si c'est const, quelle différence cela fait-il?
- En fait, après la lecture de this, je ne peux admettre avec vous. Je ne savais pas que c'était illégal en C++.
InformationsquelleAutor Fred Larson
28

Il y a plusieurs façons d'initialiser la const membres à l'intérieur de la classe..

Définition de const membre en général, les besoins de l'initialisation de la variable de trop..

1) à l'Intérieur de la classe , si vous souhaitez initialiser la const de la syntaxe, c'est comme cela
```
static const int a = 10; //at declaration
```
2) Deuxième voie 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 lors de la déclaration, puis l'autre façon est à travers constructeur, la variable doit être initialisée dans la liste d'initialisation(pas dans le corps du constructeur). Il doit être comme ceci
```
class A
{
  const int b;
  A(int c) : b(c) {} //const member initialized in initialization list
};
```
- Je pense que c'répondre à des besoins de clarification. L'utilisation du mot-clé static pour un membre de la classe n'est pas l'ajout de certains arbitraire de la syntaxe pour faire le bonheur du compilateur. Il n'y a qu'une seule copie de la variable pour toutes les instances de l'objet, constante ou non. C'est un choix de conception qui doit être examinée avec soin. En bas de la ligne, le programmeur peut décider de cette constante de la classe membre peut encore varier avec différents objets, en dépit reste constante pendant la durée de vie d'un objet donné.
- Convenu ..Lorsque nous utilisons statique, il crée juste une copie de tous les objets.. Comme vous l'avez mentionné son un choix de conception. En cas de copie unique pour tous les objets 1 et 2 devrait fonctionner. En cas de copie individuelle de chaque objet, de 3 des travaux
- Cette réponse suggère une syntaxe simple changement sans conséquences alors que la modifier pour la rendre statique ne l'est pas.
- que faire si vous avez besoin d'utiliser double ou float - est-ce une partie du C++11?
InformationsquelleAutor ravs2627
12
1. Vous pouvez mettre à niveau votre compilateur de C++11 et votre code fonctionne parfaitement.
2. Utiliser la liste d'initialisation dans le constructeur.
```
T1() : t( 100 )
{
}
```
InformationsquelleAutor borisbn
9

Si vous ne voulez pas faire la const données membres de la classe statique, Vous pouvez initialiser la const membre de données 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){}
```
- Je pense que cela offre une meilleure réponse que celle qui a été accepté....
- Merci pour le cristal clair exemples, et la variante montrant une pluralité! Éliminé de l'ambiguïté et de recherche supplémentaires/défilement de la part du lecteur!
InformationsquelleAutor GANESH B K
5

Une autre solution est
```
class T1
{
    enum
    {
        t = 100
    };

    public:
    T1();
};
```
Donc t est initialisé à 100 et il ne peut être changé et il est privé.

InformationsquelleAutor Musky

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

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

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

InformationsquelleAutor Viet Anh Do

Une autre façon possible sont des 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 les autres classes peuvent également utiliser les constantes s'ils incluent le fichier d'en-tête.

InformationsquelleAutor Baran

0

vous pouvez ajouter static afin de 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 à l'intérieur de la déclaration de classe, parce que tous les objets instacied à partir de cette classe d'actions de la même variable statique qui est stocké dans la mémoire interne de l'extérieur de la portée de la mémoire des objets instanciés.

InformationsquelleAutor dhokar.w
0

C'est la bonne façon de le faire. Vous pouvez tester 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 below alors vous ne pouvez pas initialiser les inconvénients de membre au moment de la déclaration. Donc, ici, il se doit de faire de constructeur pour initialiser le const membre de données. Il est également doit utiliser initialiser la liste T1():t(100) d'obtenir la mémoire à l'instant.

InformationsquelleAutor Gambler Aziz

Vous devez vous connecter pour publier un commentaire.