Constructeurs C++
Constructeurs C++
Dans ce didacticiel, nous allons découvrir le constructeur C++ et son type grâce aux exemples d'aide.
Un constructeur est un type spécial de fonction membre qui est appelée automatiquement lorsqu'un objet est créé.
En C++, un constructeur a le même nom que celui de la classe et il n'a pas de type de retour. Par exemple,
class Wall {
public:
// create a constructor
Wall() {
// code
}
};
Ici, la fonction Wall() est un constructeur de la classe Wall . Notez que le constructeur
- a le même nom que la classe,
- n'a pas de type de retour, et
- est
public
Constructeur par défaut C++
Un constructeur sans paramètre est appelé constructeur par défaut . Dans l'exemple ci-dessus, Wall() est un constructeur par défaut.
Exemple 1 :Constructeur par défaut C++
// C++ program to demonstrate the use of default constructor
#include <iostream>
using namespace std;
// declare a class
class Wall {
private:
double length;
public:
// default constructor to initialize variable
Wall() {
length = 5.5;
cout << "Creating a wall." << endl;
cout << "Length = " << length << endl;
}
};
int main() {
Wall wall1;
return 0;
} Sortie
Creating a Wall Length = 5.5
Ici, lorsque le wall1 objet est créé, le Wall() constructeur est appelé. Cela définit la longueur variable de l'objet à 5.5 .
Remarque : Si nous n'avons pas défini de constructeur dans notre classe, le compilateur C++ créera automatiquement un constructeur par défaut avec un code vide et aucun paramètre.
Constructeur paramétré C++
En C++, un constructeur avec des paramètres est appelé constructeur paramétré. Il s'agit de la méthode préférée pour initialiser les données des membres.
Exemple 2 :Constructeur paramétré C++
// C++ program to calculate the area of a wall
#include <iostream>
using namespace std;
// declare a class
class Wall {
private:
double length;
double height;
public:
// parameterized constructor to initialize variables
Wall(double len, double hgt) {
length = len;
height = hgt;
}
double calculateArea() {
return length * height;
}
};
int main() {
// create object and initialize data members
Wall wall1(10.5, 8.6);
Wall wall2(8.5, 6.3);
cout << "Area of Wall 1: " << wall1.calculateArea() << endl;
cout << "Area of Wall 2: " << wall2.calculateArea();
return 0;
} Sortie
Area of Wall 1: 90.3 Area of Wall 2: 53.55
Ici, nous avons créé un constructeur paramétré Wall() qui a 2 paramètres :double len et double hgt . Les valeurs contenues dans ces paramètres sont utilisées pour initialiser les variables membres longueur et hauteur .
Lorsque nous créons un objet du Wall classe, nous transmettons les valeurs des variables membres en tant qu'arguments. Le code pour cela est :
Wall wall1(10.5, 8.6);
Wall wall2(8.5, 6.3);
Avec les variables membres ainsi initialisées, nous pouvons maintenant calculer l'aire du mur avec le calculateArea() fonction.
Constructeur de copie C++
Le constructeur de copie en C++ est utilisé pour copier les données d'un objet à un autre.
Exemple 3 :Constructeur de copie C++
#include <iostream>
using namespace std;
// declare a class
class Wall {
private:
double length;
double height;
public:
// initialize variables with parameterized constructor
Wall(double len, double hgt) {
length = len;
height = hgt;
}
// copy constructor with a Wall object as parameter
// copies data of the obj parameter
Wall(Wall &obj) {
length = obj.length;
height = obj.height;
}
double calculateArea() {
return length * height;
}
};
int main() {
// create an object of Wall class
Wall wall1(10.5, 8.6);
// copy contents of wall1 to wall2
Wall wall2 = wall1;
// print areas of wall1 and wall2
cout << "Area of Wall 1: " << wall1.calculateArea() << endl;
cout << "Area of Wall 2: " << wall2.calculateArea();
return 0;
} Sortie
Area of Wall 1: 90.3 Area of Wall 2: 90.3
Dans ce programme, nous avons utilisé un constructeur de copie pour copier le contenu d'un objet du Wall classe à une autre. Le code du constructeur de copie est :
Wall(Wall &obj) {
length = obj.length;
height = obj.height;
}
Notez que le paramètre de ce constructeur a l'adresse d'un objet du Wall classe.
On affecte ensuite les valeurs des variables de l'obj objet aux variables correspondantes de l'objet appelant le constructeur de copie. C'est ainsi que le contenu de l'objet est copié.
En main() , nous créons ensuite deux objets wall1 et mur2 puis copiez le contenu de wall1 à mur2 :
// copy contents of wall1 to wall2
Wall wall2 = wall1;
Ici, le wall2 l'objet appelle son constructeur de copie en passant l'adresse du wall1 objet comme argument, c'est-à-dire &obj = &wall1 .
Remarque :Un constructeur est principalement utilisé pour initialiser des objets. Ils sont également utilisés pour exécuter un code par défaut lors de la création d'un objet.
Langue C