Constructeur en C++ est une méthode spéciale qui est invoquée automatiquement au moment de la création d'un objet. Il est utilisé pour initialiser les données membres de nouveaux objets en général. Le constructeur en C++ porte le même nom que la classe ou la structure. Il construit les valeurs, c'est-à-dire fournit des données pour l'objet, c'est pourquoi on l'appelle constructeur.
- Le constructeur est une fonction membre d'une classe dont le nom est le même que le nom de la classe.
- Le constructeur est un type spécial de fonction membre utilisé pour initialiser automatiquement les données membres d'un objet d'une classe lorsqu'un objet de la même classe est créé.
- Le constructeur est invoqué au moment de la création de l'objet. Il construit les valeurs, c'est-à-dire fournit des données pour l'objet, c'est pourquoi on l'appelle constructeur.
- Les constructeurs ne renvoient pas de valeur, ils n'ont donc pas de type de retour.
- Un constructeur est appelé automatiquement lorsque nous créons l'objet de la classe.
- Les constructeurs peuvent être surchargés.
- Un constructeur ne peut pas être déclaré virtuel.
Syntaxe des constructeurs en C++
Le prototype du constructeur ressemble à ceci :
(list-of-parameters);>
Le constructeur peut être défini dans la déclaration de classe ou en dehors de la déclaration de classe
Syntaxe pour définir le constructeur dans la classe
(list-of-parameters) { // constructor definition }> Syntaxe pour définir le constructeur en dehors de la classe
: :(list-of-parameters) { // constructor definition }> Exemples de constructeurs en C++
Les exemples ci-dessous montrent comment déclarer des constructeurs pour une classe en C++ :
Exemple 1 : Définition du constructeur dans la classe
C++
// defining the constructor within the class> #include> using> namespace> std;> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >// constructor> >student()> >{> >cout <<>'Enter the RollNo:'>;> >cin>>rno;> >cout <<>'Enter the Name:'>;> >cin>> nom ;> >cout <<>'Enter the Fee:'>;> >cin>> frais ;> >}> >void> display()> >{> >cout << endl << rno <<>' '> << name <<>' '> << fee;> >}> };> int> main()> {> >student s;>// constructor gets called automatically when> >// we create the object of the class> >s.display();> >return> 0;> }> |
>
>
Sortir
Enter the RollNo:121 Enter the Name:Geeks Enter the Fee:5000 121 Geeks 5000>
Exemple 2 : Définition du constructeur en dehors de la classe
C++
// defining the constructor outside the class> #include> using> namespace> std;> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >// constructor declaration only> >student();> >void> display();> };> // outside definition of constructor> student::student()> {> >cout <<>'Enter the RollNo:'>;> >cin>>rno;> >cout <<>'Enter the Name:'>;> >cin>> nom ;> >cout <<>'Enter the Fee:'>;> >cin>> frais ;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> // driver code> int> main()> {> >student s;> >s.display();> >return> 0;> }> |
>
>
Sortir
Enter the RollNo:11 Enter the Name:Aman Enter the Fee:10111 11 Aman 10111>
Note: Nous pouvons définir le constructeur en dehors de la classe comme en ligne pour la rendre équivalente à la définition en classe. Mais notez que en ligne n'est pas une instruction destinée au compilateur, c'est seulement la requête que le compilateur peut ou non implémenter selon les circonstances.
Caractéristiques des constructeurs en C++
Voici quelques principales caractéristiques des constructeurs en C++ :
- Le nom du constructeur est le même que son nom de classe.
- Les constructeurs sont généralement déclarés dans la section publique de la classe bien qu'ils puissent l'être dans la section privée de la classe.
- Les constructeurs ne renvoient pas de valeurs ; ils n'ont donc pas de type de retour.
- Un constructeur est appelé automatiquement lorsque nous créons l'objet de la classe.
- Les constructeurs peuvent être surchargés.
- Un constructeur ne peut pas être déclaré virtuel.
- Un constructeur ne peut pas être hérité.
- Les adresses du Constructeur ne peuvent être mentionnées.
- Le constructeur effectue des appels implicites à nouveau et supprimer opérateurs lors de l’allocation de mémoire.
Types de constructeur en C++
Les constructeurs peuvent être classés en fonction des situations dans lesquelles ils sont utilisés. Il existe 4 types de constructeurs en C++ :
- Constructeur par défaut
- Constructeur paramétré
- Copier le constructeur
- Déplacer le constructeur
Comprenons les types de constructeurs en C++ en prenant un exemple concret. Supposons que vous alliez dans un magasin pour acheter un marqueur. Lorsque vous souhaitez acheter un marqueur, quelles sont les options ? Le premier, tu vas dans un magasin et tu dis donne-moi un marqueur. Donc, dire simplement donnez-moi un marqueur signifie que vous n'avez pas défini quel nom de marque et quelle couleur, vous n'avez rien mentionné, dites simplement que vous voulez un marqueur. Ainsi, lorsque nous avons simplement dit que je voulais un marqueur, quel que soit le marqueur fréquemment vendu sur le marché ou dans son magasin, il le remettra simplement. Et voilà ce qu’est un constructeur par défaut !
La deuxième méthode consiste à vous rendre dans un magasin et à dire que je veux un marqueur de couleur rouge et de la marque XYZ. Donc, vous en parlez et il vous donnera ce marqueur. Donc dans ce cas vous avez donné les paramètres. Et voilà ce qu’est un constructeur paramétré !
Ensuite, le troisième, vous allez dans un magasin et dites que je veux un marqueur comme celui-ci (un marqueur physique sur votre main). Le commerçant verra donc ce marqueur. D'accord, et il vous donnera un nouveau marqueur. Donc copie de ce marqueur. Et c’est ça, un constructeur de copie !
Supposons maintenant que vous n’achetiez pas un nouveau marqueur, mais que vous deveniez propriétaire du marqueur de votre ami. Cela signifie s’approprier des ressources déjà présentes au lieu d’en acquérir de nouvelles. C’est ça un constructeur de mouvements !
1. Constructeur par défaut en C++
UN constructeur par défaut est un constructeur qui ne prend aucun argument. Il n'a aucun paramètre. On l'appelle également constructeur sans argument.
Syntaxe du constructeur par défaut
className() { // body_of_constructor }> Exemples de constructeur par défaut
Les exemples ci-dessous montrent comment utiliser les constructeurs par défaut en C++.
Exemple 1:
RPC
// C++ program to illustrate the concept of default> // constructors> #include> using> namespace> std;> class> construct {> public>:> >int> a, b;> >// Default Constructor> >construct()> >{> >a = 10;> >b = 20;> >}> };> int> main()> {> >// Default constructor called automatically> >// when the object is created> >construct c;> >cout <<>'a: '> << c.a << endl <<>'b: '> << c.b;> >return> 1;> }> |
>
>Sortir
a: 10 b: 20>
Note: Même si nous ne définissons explicitement aucun constructeur, le compilateur fournira automatiquement et implicitement un constructeur par défaut.
Exemple 2 :
C++
// C++ program to demonstrate the implicit default> // constructor> #include> using> namespace> std;> // class> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> };> int> main()> {> >// creating object without any parameters> >student s;> >return> 0;> }> |
>
>
Sortir
(no output)>
Comme nous pouvons le voir, nous pouvons créer l’objet de la classe student sans passer aucun argument même si nous n’avons défini aucun constructeur par défaut explicite pour celui-ci.
2. Constructeur paramétré en C++
Les constructeurs paramétrés permettent de passer des arguments aux constructeurs. Généralement, ces arguments permettent d'initialiser un objet lors de sa création. Pour créer un constructeur paramétré, ajoutez-y simplement des paramètres comme vous le feriez pour n'importe quelle autre fonction. Lorsque vous définissez le corps du constructeur, utilisez les paramètres pour initialiser l'objet.
exemple de sous-chaîne Java
Syntaxe du constructeur paramétré
className (parameters...) { // body }> Exemples de constructeur paramétré
Les exemples ci-dessous montrent comment utiliser les constructeurs paramétrés en C++.
Exemple 1 : Définition d’un constructeur paramétré à l’intérieur de la classe.
RPC
// CPP program to illustrate parameterized constructors> #include> using> namespace> std;> class> Point {> private>:> >int> x, y;> public>:> >// Parameterized Constructor> >Point(>int> x1,>int> y1)> >{> >x = x1;> >y = y1;> >}> >int> getX() {>return> x; }> >int> getY() {>return> y; }> };> int> main()> {> >// Constructor called> >Point p1(10, 15);> >// Access values assigned by constructor> >cout <<>'p1.x = '> << p1.getX()> ><<>', p1.y = '> << p1.getY();> >return> 0;> }> |
>
>Sortir
p1.x = 10, p1.y = 15>
Exemple 2 : Définition d'un constructeur paramétré en dehors de la classe.
C++
// C++ Program to illustrate how to define the parameterized> // constructor outside the class> #include> #include> using> namespace> std;> // class definition> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >student(>int>,>char>[],>double>);> >void> display();> };> // parameterized constructor outside class> student::student(>int> no,>char> n[],>double> f)> {> >rno = no;> >strcpy>(name, n);> >fee = f;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> // driver code> int> main()> {> >student s(1001,>'Ram'>, 10000);> >s.display();> >return> 0;> }> |
>
>Sortir
1001 Ram 10000>
Lorsqu'un objet est déclaré dans un constructeur paramétré, les valeurs initiales doivent être passées en arguments à la fonction constructeur. La méthode normale de déclaration d'objet peut ne pas fonctionner. Les constructeurs paramétrés peuvent être appelés explicitement ou implicitement :
Example e = Example(0, 50); // Explicit call Example e(0, 50); // Implicit call>
Lorsque le constructeur paramétré est défini et qu'aucun constructeur par défaut n'est défini explicitement, le compilateur ne créera pas implicitement le constructeur par défaut et créera donc un objet simple comme :
Student s;>
fera clignoter une erreur.
Exemple 3 :
C++
// C++ Program to illustrate the error caused be not> // defining the explicit defualt constructor after> // parameterized constructor> #include> #include> using> namespace> std;> // class definition> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >student(>int> no,>char> n[],>double> f)> >{> >rno = no;> >strcpy>(name, n);> >fee = f;> >}> };> // driver code> int> main()> {> >student s;>// this will cause error> >return> 0;> }> |
>
>
Sortir
main.cpp: In function ‘int main()’: main.cpp:25:13: error: no matching function for call to ‘student::student()’ 25 | student s; // this will cause error | ^ main.cpp:14:5: note: candidate: ‘student::student(int, char*, double)’ 14 | student(int no, char n[], double f) | ^~~~~~~ main.cpp:14:5: note: candidate expects 3 arguments, 0 provided main.cpp:8:7: note: candidate: ‘constexpr student::student(const student&)’ 8 | class student { | ^~~~~~~ main.cpp:8:7: note: candidate expects 1 argument, 0 provided main.cpp:8:7: note: candidate: ‘constexpr student::student(student&&)’ main.cpp:8:7: note: candidate expects 1 argument, 0 provided ^~> Note importante: Chaque fois que nous définissons un ou plusieurs constructeurs autres que ceux par défaut (avec paramètres) pour une classe, un constructeur par défaut (sans paramètres) doit également être explicitement défini car le compilateur ne fournira pas de constructeur par défaut dans ce cas. Cependant, ce n’est pas nécessaire mais il est considéré comme la meilleure pratique de toujours définir un constructeur par défaut.
Utilisations du constructeur paramétré
- Il permet d'initialiser les différents éléments de données de différents objets avec des valeurs différentes lors de leur création.
- Il est utilisé pour surcharger les constructeurs.
Arguments par défaut avec le constructeur paramétré C++
Tout comme les fonctions normales, nous pouvons également définir des valeurs par défaut pour les arguments des constructeurs paramétrés. Toutes les règles du arguments par défaut sera appliqué à ces paramètres.
Exemple 3 : Définition d'un constructeur paramétré avec des valeurs par défaut
C++
// C++ Program to illustrate how to use default arguments> // with parameterized constructor> #include> using> namespace> std;> // class> class> GFG {> private>:> >int> data;> public>:> >// parameterized constructor with default values> >GFG(>int> x = 0) { data = x; }> >int> getData() {>return> data; }> };> int> main()> {> >GFG obj1;>// will not throw error> >GFG obj2(25);> >cout <<>'First Object Data: '> << obj1.getData() << endl;> >cout <<>'Second Object Data: '> << obj2.getData()> ><< endl;> >return> 0;> }> |
>
>Sortir
First Object Data: 0 Second Object Data: 25>
Comme nous pouvons le voir, lorsque les valeurs par défaut sont assignées à chaque argument du constructeur paramétré, il est légal de créer l'objet sans passer de paramètres, tout comme les constructeurs par défaut. Ainsi, ce type de constructeur fonctionne à la fois comme constructeur par défaut et paramétré.
3. Copier le constructeur en C++
Un constructeur de copie est une fonction membre qui initialise un objet en utilisant un autre objet de la même classe.
Syntaxe de Copier le constructeur
Copier le constructeur prend une référence à un objet de la même classe comme argument.
ClassName (ClassName &obj) { // body_containing_logic }> Tout comme le constructeur par défaut, le compilateur C++ fournit également un constructeur de copie implicite si la définition explicite du constructeur de copie n'est pas présente. Ici, il est à noter que, contrairement au constructeur par défaut où la présence de tout type de constructeur explicite entraîne la suppression du constructeur implicite par défaut, le constructeur de copie implicite sera toujours créé par le compilateur s'il n'y a pas de constructeur de copie explicite. ou un constructeur de déplacement explicite est présent.
Exemples de constructeur de copie
Les exemples ci-dessous montrent comment utiliser les constructeurs de copie en C++.
Exemple 1 : Illustration du constructeur de copie implicite
C++
// C++ program to illustrate the use of Implicit copy> // constructor> #include> using> namespace> std;> class> Sample {> >int> id;> public>:> >// parameterized constructor> >Sample(>int> x) { id = x; }> >void> display() { cout <<>'ID='> << id; }> };> int> main()> {> >Sample obj1(10);> >obj1.display();> >cout << endl;> >// creating an object of type Sample from the obj> >Sample obj2(obj1);>// or obj2=obj1;> >obj2.display();> >return> 0;> }> |
>
>Sortir
ID=10 ID=10>
Exemple 2 : Définition du constructeur de copie explicite
C++
// C++ Program to demonstrate how to define the explicit> // copy constructor> #include> using> namespace> std;> class> Sample {> >int> id;> public>:> >// default constructor with empty body> >Sample() {}> >// parameterized constructor> >Sample(>int> x) { id = x; }> >// copy constructor> >Sample(Sample& t) { id = t.id; }> >void> display() { cout <<>'ID='> << id; }> };> // driver code> int> main()> {> >Sample obj1(10);> >obj1.display();> >cout << endl;> >// copy constructor called> >Sample obj2(obj1);>// or obj2=obj1;> >obj2.display();> >return> 0;> }> |
>
programme Java
>Sortir
ID=10 ID=10>
Exemple 3 : Définition d'un constructeur de copie explicite avec un constructeur paramétré
C++
// C++ program to demonstrate copy construction along with> // parameterized constructor> #include> #include> using> namespace> std;> // class definition> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >student(>int>,>char>[],>double>);> >student(student& t)>// copy constructor> >{> >rno = t.rno;> >strcpy>(name, t.name);> >fee = t.fee;> >}> >void> display();> };> student::student(>int> no,>char> n[],>double> f)> {> >rno = no;> >strcpy>(name, n);> >fee = f;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> int> main()> {> >student s(1001,>'Manjeet'>, 10000);> >s.display();> >student manjeet(s);>// copy constructor called> >manjeet.display();> >return> 0;> }> |
>
>Sortir
1001 Manjeet 10000 1001 Manjeet 10000>
Utilisations du constructeur de copie
- Construit un nouvel objet en copiant les valeurs d'un objet existant.
- Peut être utilisé pour effectuer une copie complète.
- Modifiez des attributs spécifiques pendant le processus de copie si nécessaire.
4. Déplacer le constructeur en C++
Le constructeur de déplacement est un ajout récent à la famille des constructeurs en C++. C'est comme un constructeur de copie qui construit l'objet à partir des objets déjà existants, mais au lieu de copier l'objet dans la nouvelle mémoire, il utilise la sémantique de déplacement pour transférer la propriété de l'objet déjà créé vers le nouvel objet sans créer d'objets supplémentaires. copies.
Cela peut être considéré comme un vol de ressources sur d’autres objets.
Syntaxe du constructeur de déplacement en C++
className (className&& obj) { // body of the constructor }> Le déplacer le constructeur prend le référence de valeur r de l'objet de la même classe et transfère la propriété de cet objet à l'objet nouvellement créé.
Comme un constructeur de copie, le compilateur créera un constructeur de déplacement pour chaque classe qui n'a pas de constructeur de déplacement explicite.
Exemples de constructeur de déplacement
Les exemples ci-dessous montrent comment utiliser les constructeurs de déplacement en C++.
Exemple 1 : Définition du constructeur de déplacement
C++
// C++ Program to illustrate how to define a move> // constructor> #include> using> namespace> std;> class> Box {> public>:> >int>* data;>// Pointer to an integer value> >// Constructor> >Box(>int> value)> >{> >data =>new> int>;> >*data = value;> >}> >// Move constructor> >Box(Box&& other) noexcept> >{> >cout <<>'Move Constructor Called'> << endl;> >data = other.data;>// Transfer ownership of 'other'> >// data> >other.data = nullptr;>// Null out 'other' to prevent> >// double deletion> >}> >// Destructor> >~Box() {>delete> data; }> };> int> main()> {> >// Create a Box with value 42> >Box originalBox(42);> >// Create a new Box by moving resources from the> >// originalBox> >Box newBox(move(originalBox));> >cout <<>'newBox.data: '> << *newBox.data;> >// originalBox is now in a valid but unspecified> >// state (its resources were moved to newBox)> >return> 0;> }> |
>
>Sortir
Move Constructor Called newBox.data: 42>
Utilisations du constructeur de déplacement
- Au lieu de faire des copies, les constructeurs de déménagements transfèrent efficacement la propriété de ces ressources.
- Cela évite la copie inutile de la mémoire et réduit les frais généraux.
- Vous pouvez définir votre propre constructeur de déplacement pour gérer des transferts de ressources spécifiques.
Destructeurs en C++
Un destructeur est également une fonction membre spéciale en tant que constructeur. Le destructeur détruit les objets de classe créés par le constructeur. Le destructeur a le même nom que son nom de classe précédé d'un symbole tilde (~). Il n'est pas possible de définir plus d'un destructeur. Le destructeur n'est qu'un moyen parmi d'autres de détruire l'objet créé par le constructeur. Par conséquent, le destructeur ne peut pas être surchargé. Le destructeur ne nécessite aucun argument et ne renvoie aucune valeur. Il est automatiquement appelé lorsque l'objet sort de la portée. Les destructeurs libèrent l'espace mémoire occupé par les objets créés par le constructeur. Dans destructeur , les objets sont détruits à l'inverse de la création d'objets.
Syntaxe des destructeurs en C++
Comme les constructeurs, les destructeurs peuvent également être définis à l’intérieur ou à l’extérieur de la classe.
La syntaxe pour définir le destructeur au sein de la classe
~ (){}> La syntaxe pour définir le destructeur en dehors de la classe
: : ~(){}> Exemples de destructeurs en C++
Les exemples ci-dessous montrent comment utiliser les destructeurs en C++.
Exemple 1 : Définition d'un destructeur simple
C++
#include> using> namespace> std;> class> Test {> public>:> >Test() { cout <<>'
Constructor executed'>; }> >~Test() { cout <<>'
Destructor executed'>; }> };> main()> {> >Test t;> >return> 0;> }> |
>
>Sortir
Constructor executed Destructor executed>
Exemple 2 : compter le nombre de fois qu'un objet est créé et détruit
C++
// C++ Program to count the number of objects created and> // destroyed> #include> using> namespace> std;> // global variable to count> int> count = 0;> // class definition> class> Test {> public>:> >Test()> >{> >count++;> >cout <<>'No. of Object created: '> << count << endl;> >}> >~Test()> >{> >cout <<>'No. of Object destroyed: '> << count> ><< endl;> >--count;> >}> };> // driver code> int> main()> {> >Test t, t1, t2, t3;> >return> 0;> }> |
>
>
Sortir
No. of Object created: 1 No. of Object created: 2 No. of Object created: 3 No. of Object created: 4 No. of Object destroyed: 4 No. of Object destroyed: 3 No. of Object destroyed: 2 No. of Object destroyed: 1>
Caractéristiques des destructeurs en C++
Voici quelques principales caractéristiques des destructeurs en C++ :
- Le destructeur est invoqué automatiquement par le compilateur lorsque son constructeur correspondant sort de la portée et libère l'espace mémoire qui n'est plus requis par le programme.
- Le destructeur ne nécessite aucun argument et ne renvoie aucune valeur, il ne peut donc pas être surchargé.
- Le destructeur ne peut pas être déclaré comme static et const ;
- Le destructeur doit être déclaré dans la section publique du programme.
- Le destructeur est appelé dans l'ordre inverse de son invocation de constructeur.
Foire aux questions sur les constructeurs C++
Quelles sont les fonctions générées par défaut par le compilateur, si nous ne les fournissons pas explicitement ?
Les fonctions générées par défaut par le compilateur si nous ne les fournissons pas explicitement sont :
- Constructeur par défaut
- Copier le constructeur
- Déplacer les constructeurs
- Opérateur d'assignation
- Destructeur
Pouvons-nous rendre les constructeurs privés ?
Oui, en C++, les constructeurs peuvent être rendus privés. Cela signifie qu'aucun code externe ne peut créer directement un objet de cette classe.
En quoi les constructeurs sont-ils différents d'une fonction membre normale ?
Un constructeur diffère des fonctions normales des manières suivantes :
- Le constructeur a le même nom que la classe elle-même
- Les constructeurs par défaut n'ont pas d'argument d'entrée, cependant, les constructeurs de copie et paramétrés ont des arguments d'entrée
- Les constructeurs n'ont pas de type de retour
- Un constructeur est automatiquement appelé lors de la création d'un objet.
- Il doit être placé dans la section publique de la classe.
- Si nous ne spécifions pas de constructeur, le compilateur C++ génère un constructeur par défaut pour l'objet (n'attend aucun paramètre et a un corps vide).
Pouvons-nous avoir plus d’un constructeur dans une classe ?
Oui, nous pouvons avoir plus d’un constructeur dans une classe. On l'appelle Surcharge du constructeur .
Articles Liés:
- Destructeurs en C++
- Quiz sur les constructeurs en C++
- Sortie des programmes C++ | Ensemble 26 (Constructeurs)
- Sortie des programmes C++ | Ensemble 27 (Constructeurs et Destructeurs)