initializer lists c
Explorez tout sur les listes d'initialiseurs en C ++ avec des exemples en détail.
C ++ utilise des listes d'initialiseurs pour initialiser les membres de données à leurs valeurs.
Les listes d'initialiseurs sont principalement utilisées dans des situations spécifiques où il n'est pas possible d'initialiser les valeurs dans le corps du constructeur.
comment testeriez-vous un stylo
=> Cliquez ici pour le cours C ++ gratuit.
Listes d'initialisation en C ++
La syntaxe générale de la liste des initialiseurs est:
constructorName(type value1, type value2):datamember(value1), datamember(value2) { //constructor code } Certaines de ces situations où les listes d'initialiseurs sont utilisées sont répertoriées ci-dessous:
# 1) Un constructeur par défaut n'est pas fourni pour la classe d'objets membres.
Lorsque nous avons un autre objet de classe comme membre de la classe et que la classe de cet objet n’a pas de constructeur par défaut, nous initialisons cet objet de membre de données à l’aide de la liste d’initialiseur.
Ceci est illustré dans le programme suivant.
#include using namespace std; class A { int i; public: A(int ); }; A::A(int val) { i = val; cout << 'Constructor ::A ; i = ' << i << endl; } class B { A a; public: B(int ); }; B::B(int val):a(val) { cout << 'Constructor :: B'; } int main() { B obj(10); return 0; }Production:
Constructeur :: A; i = 10
Constructeur :: B
Dans le programme ci-dessus, l'objet de la classe A est une donnée membre de la classe B. Dans la classe A, nous avons un constructeur paramétré mais pas un constructeur par défaut. Nous devons donc utiliser la liste d'initialiseurs dans la classe B, afin de créer un objet de classe A.
# 2) Initialisation de C nos données membres.
Comme les membres de données const ne peuvent être initialisés qu'une seule fois, nous les initialisons à l'aide de la liste d'initialisation.
Nous démontrons cela à l'aide de l'exemple suivant.
#include using namespace std; class sample { private: const int val; public: sample(int val):val(val) { cout << 'Value is ' << val; } }; int main() { sample obj(10); }Production:
La valeur est 10
Dans le programme ci-dessus, nous avons un const comme membre de données. Si nous devons initialiser ce membre const à une valeur, nous le faisons en utilisant la liste d'initialisation comme indiqué.
# 3) Pour l'initialisation des types de données de référence.
Comme les constantes, les références sont immuables. Ainsi, chaque fois que nous devons initialiser les membres de données de type référence, nous utilisons des listes d'initialiseurs.
Dans le programme suivant, nous initialisons le membre de données de référence à l'aide de la liste d'initialisation.
#include using namespace std; class sample { private: int &ref_val; public: sample(int &ref_val):ref_val(ref_val) { cout << 'Value is ' << ref_val; } }; int main() { int ref=10; sample obj(ref); return 0; } Production:
La valeur est 10
Dans ce programme, nous avons une référence en tant que membre de données et nous l'initialisons à l'aide de la liste d'initialisation.
# 4) Lorsque le nom du membre et le paramètre ont le même nom.
comment exécuter un fichier .bin
Lorsque les noms de membres d'une classe doivent être initialisés avec les paramètres et que ces paramètres ont les mêmes noms que les noms de membres, nous utilisons la liste d'initialisation. Dans nos rubriques précédentes, nous avons utilisé ce pointeur pour la même situation. La deuxième option est la liste d'initialisation.
Nous avons modifié l'exemple ci-dessus avec ce pointeur pour utiliser la liste d'initialisation dans le programme suivant.
#include using namespace std; class Sample { private: int num; char ch; public: Sample(int num,char ch):num(num),ch(ch){ cout<<'num = '< Production:
num = 100
ch = A
Dans ce programme, nous passons des paramètres pour initialiser les membres de données ayant les mêmes noms. Dans ce cas, nous utilisons la liste d'initialisation à cet effet.
# 5) Pour améliorer les performances
Chaque fois que nous initialisons les membres de données dans le corps du constructeur, un objet temporaire est créé pour le membre de données lors de l'affectation de valeurs. Une fois l'affectation terminée, cet objet temporaire est supprimé. C'est en fait une surcharge.
Si nous utilisons la liste d'initialiseurs, en revanche, un constructeur de copie est utilisé pour attribuer des valeurs. Cela améliore considérablement les performances.
Conclusion
Ainsi, dans ce tutoriel, nous avons découvert les listes d'initialiseurs ainsi que de nombreuses situations dans lesquelles nous devons les utiliser en programmation C ++.
Bien que nous n'ayons pas besoin d'utiliser la liste d'initialisation lorsque ces situations ne sont pas présentes, nous pouvons toujours les utiliser pour améliorer les performances du programme.
Dans notre prochain didacticiel, nous aborderons en détail les fonctions d'ami en C ++.
=> Voir ici pour explorer la liste complète des didacticiels C ++.
lecture recommandée
