C++ Membre De La Liste D'Initialisation

Veuillez expliquer comment utiliser l'initialisation de membre listes.
J'ai une classe déclarée dans un .h fichier et un .cpp fichier comme ceci:

class Example
{
private:
    int m_top;
    const int m_size;
    ...
public:
    Example ( int size, int grow_by = 1 ) : m_size(5), m_top(-1);
    ...
    ~Example();
};

Je suis initialisation m_size sur la création d'objet en raison de const. Comment dois-je écrire le constructeur?
Dois-je répéter : m_size(5), m_top(-1), ou je pouvez omettre cette étape?

Example::Example( int size, int grow_by)
{
... some code here
}

Example::Example( int size, int grow_by) : m_size(5), m_top(-1)
{
... some code here
}

Vous spécifiez la liste d'initialisation lorsque vous définissez le constructeur, et non pas lorsque vous déclarez.

InformationsquelleAutor Yesman | 2011-10-05

c++

22

C'est la liste d'initialisation :
```
Example::Example( int size, int grow_by) : m_size(5), m_top(-1)
{
... some code here
}
```
et il devrait être fait seulement dans le fichier cpp.

Ne pas vous obtenez une erreur lorsque vous le faites comme vous l'avez fait dans l'en-tête dans votre exemple?

InformationsquelleAutor BЈовић
58

Juste clarifier quelque chose qui est venu dans certaines autres réponses...

Il n'est pas nécessaire que la liste d'initialisation être soit à la source (.rpc) ou de l'en-tête (.h) fichier. En fait, le compilateur ne fait pas de distinction entre les deux types de fichiers. La distinction importante entre le constructeur de l' déclaration et c'est la définition. La liste d'initialisation va de pair avec la définition de la déclaration.

Habituellement, la déclaration est dans un fichier d'en-tête et la définition est dans un fichier source, cependant, ce n'est pas une exigence de la langue (c'est à dire de compiler).
Il n'est pas inhabituel de prévoir constructeur de définitions en ligne dans la déclaration de classe lorsque le constructeur est vide ou court. Dans ce cas, une liste d'initialisation serait aller à l'intérieur de la déclaration de la classe, qui sera probablement dans un fichier d'en-tête.

MyClass.h
```
class MyClass
{
public:
    MyClass(int value) : m_value(value)
    {}
private:
    int m_value;
};
```
- Remarque: certains cadres et les langues comme Qt C++ exigent de leurs classes et les structures dérivées de QObject d'utiliser leur propre en-tête pour tirer parti de leur Q_OBJECT macro pour bien profiter de son potentiel.
InformationsquelleAutor BHS
13

Membre de l'Initialiseur liste est une partie de la définition dans le fichier source.

Écrire cela dans un fichier cpp:
```
Example ( int size, int grow_by) : m_size(5), m_top(-1)
{

}
```
Fichier d'en-tête ne doit avoir:
```
Example ( int size, int grow_by = 1 );
```
Fichier d'en-tête uniquement déclare le constructeur, Membre de l'Initialiseur liste n'est pas une partie de la déclaration.
- I. e. initialiser la liste ne va que dans le constructeur de la définition.
- Oh un peu de retard, juste s'il avait édité avant ton commentaire 😛
- Je pense que le = 1 paramètre par défaut ne doit être dans l'en-tête, pas la cpp fichier.
- Correct! Ah err cntrl + c, cntrl + v Mauvaise habitude :P!
- En outre, les données membres sont initialisées dans l'ordre où elles sont déclarées, de sorte qu'il est de bonne pratique de l'ordre de votre liste d'initialiseur de la même manière à être compatibles. Dans votre exemple, ce serait : m_top(-1), m_size(5). Voir Efficace C++ par Meyers, Point 4).
InformationsquelleAutor Alok Save
9

Ajoutant à d'autres réponses, la plus importante chose que l'on devrait retenir à propos de l'initialisation de la liste, c'est que, the order of initialization is decided in the order in which the data members are declared, not the the order in which you have initialized the data members using initialization list

Prenons l'exemple (la Vôtre):
```
class Example
{
private:
    int m_top;
    const int m_size;
    ...
public:
    Example ( int size, int grow_by = 1 ) : m_size(5), m_top(-1){}

                   /* Though size is initialized with a value first
                       But it is m_top variable that is assigned value -1
                       before m_size is assigned value 5 */
    ...
    ~Example(){}
};
 
```
Si l'on n'est pas conscient de ce qui précède, il peut provoquer de très graves conséquences.
- De nombreux compilateurs de les avertir de l'ordre d'initialisation si il semble que il peut y avoir une ambiguïté qui pourrait causer des problèmes. Vous devriez permettre à ces mises en garde s'ils ne sont pas et de prêter attention à ces avertissements.
- Oui, mais encore la peine assez pour savoir ce que l'avertissement est vraiment 🙂
- Viens de vérifier votre profil. Thèse de doctorat en physique nucléaire!! impressionnant. 🙂
InformationsquelleAutor Arunmu
1

En C++11, vous pouvez utiliser non statique des données d'initialisation de membre. Ceci est particulièrement utile si vous avez plusieurs constructeurs qui ont besoin d'une valeur commune pour une variable membre.
```
class Example
{
private:
    int m_top = -1;
    const int m_size = 5;
    ...
public:
    Example ( int size, int grow_by = 1 );
    ...
    ~Example();
};

...

Example::Example( int size, int grow_by )
{
    ... some code here
}
```
Vous pouvez remplacer la valeur dans un constructeur, si vous en avez besoin.

InformationsquelleAutor emsr
1

Vous ne pouvez pas avoir de l'initialisation de la liste à la fois dans l'en-tête et du rpc. La liste devrait être dans tout ce qui a jamais défini dans le fichier de votre constructeur. Vous devez également inclure un corps pour le constructeur, même si elle est vide.

Sur une note de côté, vous ne devez spécifier la valeur par défaut des arguments dans le prototype de fonction non pas dans la définition.

InformationsquelleAutor minus

Vous devez vous connecter pour publier un commentaire.