Constructeurs C++ :utilisation d'arguments par défaut pour la création d'objets flexibles

Un constructeur est une fonction membre spéciale dans une classe, qui est automatiquement appelée lors de la création d'un objet. Ceux-ci sont utilisés pour initialiser l'objet avec des valeurs ou des paramètres par défaut.

Alors que les arguments par défaut en C++ permettent de spécifier des valeurs par défaut pour les paramètres de fonction ou de constructeur.

Constructeur avec arguments par défaut

Un constructeur avec des arguments par défaut est un constructeur qui permet de créer un objet à l'aide de paramètres facultatifs. Où les valeurs par défaut des paramètres sont fournies, donc lorsque l'utilisateur ne transmet aucune valeur, la valeur par défaut est utilisée.

Syntaxe

Voici la syntaxe donnée pour le constructeur avec les arguments par défaut :

class ClassName {
 public:
 ClassName(parameter_Type parameter_Name = default_Value,
 parameter_Type2 parameter_Name2 = default_Value2);
};

• Ici, le constructeur porte le même nom que la classe
• Des valeurs par défaut sont fournies pour un ou plusieurs paramètres.
• Si aucune valeur n'est transmise par l'utilisateur, alors cette valeur par défaut sera utilisée.

Exemple de constructeur avec arguments par défaut

Voici l'exemple suivant pour un constructeur avec des arguments par défaut :

#include <iostream>
using namespace std;
// Function with a default argument
void printMessage(string message = "Hello, Tutorialspoint Learner") {
 cout << message << endl;
}
int main() {
 // Calling the function without an argument
 printMessage(); // Prints the default message: "Hello, World!"
 
 // Calling the function with a custom argument
 printMessage("Hi, there!"); // Prints the custom message: "Hi, there!"
 return 0;
}

Sortie

Hello, Tutorialspoint Learner
Hi, there!

Explication

• Une fonction printMessage() est créé, donnant un paramètre de valeur par défaut "Bonjour, Tutorialspoint Learner".
• Maintenant dans main(), printMessage() La fonction est appelée sans aucun argument, donc l'argument par défaut "Bonjour, Tutorialspoint Learner" est utilisé.
• alors que dans printMessage("Salut, là-bas !") , nous avons explicitement passé la valeur "Salut, là !" cela remplacera donc l'argument par défaut.

Constructeur avec plusieurs arguments par défaut

Un constructeur avec plusieurs arguments par défaut permet à l'utilisateur de spécifier les valeurs par défaut de plusieurs paramètres. Cela offre plus de flexibilité et d'accès pour transmettre n'importe quelle combinaison d'arguments.

Exemple

Voici l'exemple suivant pour un constructeur avec plusieurs arguments par défaut :

#include <iostream>
using namespace std;
class Box {
 public:
 int length, width, height;
 // Constructor with multiple default arguments
 Box(int l = 5, int w = 10, int h = 2) { // Default values for length, width, and height
 length = l;
 width = w;
 height = h;
 }
 void display() {
 cout << "Length: " << length << ", Width: " << width << ", Height: " << height << endl;
 }
};
int main() {
 // Creating objects with different numbers of arguments
 Box box1; 
 Box box2(15); 
 Box box3(15, 20); 
 Box box4(15, 20, 25); 
 // Displaying the objects' values
 box1.display();
 box2.display();
 box3.display();
 box4.display();
 return 0;
}

Sortie

Length: 5, Width: 10, Height: 2
Length: 15, Width: 10, Height: 2
Length: 15, Width: 20, Height: 2
Length: 15, Width: 20, Height: 25

Explication

• Tout d'abord, la classe box est définie avec trois variables membres publiques :length et width, où le constructeur Box(int l =5, int w =10, int h =2) a des arguments par défaut pour les trois paramètres.
• Dans l'objet Box box1 ; aucun argument n'est fourni, donc le constructeur par défaut est appelé avec les valeurs par défaut, ce qui donne "Longueur : 5, Largeur : 10, Hauteur : 2".
• Dans Box box2(15); la longueur est fournie à 15, mais la largeur et la hauteur ne sont pas fournies. Il utilise donc respectivement les valeurs par défaut.
• Dans Box box3(15, 20) ; la longueur et la largeur reçoivent respectivement les valeurs 15 et 20, elles remplaceront donc les valeurs par défaut et donneront le résultat en conséquence.

Principales fonctionnalités des constructeurs avec arguments par défaut

Bien qu'elle soit similaire aux fonctions classiques, elle offre plus de flexibilité et de commodité lors de la création d'objets.

Ici, dans ce qui suit, nous discuterons de toutes ses fonctionnalités clés.

1. Valeurs par défaut pour les paramètres et flexibilité dans la création d'objets

Ici, le constructeur peut avoir des valeurs par défaut pour un ou plusieurs paramètres, qui peuvent être utilisées lorsqu'aucun argument n'est fourni par l'appelant et permettent plusieurs façons de créer un objet.

2. Éviter les surcharges de plusieurs constructeurs

Vous devrez peut-être charger le constructeur pour chaque combinaison d'arguments, ce qui rendra le code plus volumineux, mais avec les arguments par défaut, le constructeur peut être écrit une fois et il gérera automatiquement différents cas.

3. Ordre des arguments par défaut

Dans le cas de plusieurs paramètres de valeur par défaut, vous ne pouvez pas ignorer les arguments par défaut au milieu une fois que vous commencez à fournir les valeurs par défaut à partir de la droite.

Syntaxe

Box(int l = 1, int w); // Invalid: 'w' has no default, but 'l' does.

4. Les arguments par défaut peuvent être utilisés avec les membres Const

Si votre classe a des membres const, alors les arguments par défaut peuvent être fournis dans le constructeur pour faciliter l'initialisation.

Syntaxe

class Box {
 public:
 const int length, width;
 Box(int l = 5, int w = 10) : length(l), width(w) {}
};

Ce constructeur utilise des arguments par défaut (longueur =5 et largeur =10) pour initialiser les membres const.