Constructeurs C++ : Utilisation d'arguments par défaut pour une création d'objets flexible

Un constructeur est une fonction membre spéciale dans une classe, qui est automatiquement appelée lorsqu'un objet est créé. 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 arguments par défaut est un constructeur qui permet la création d'un objet en utilisant des paramètres optionnels. Où les valeurs par défaut pour les paramètres sont fournies, donc quand l'utilisateur ne passe aucune valeur, la valeur par défaut est utilisée.

Syntaxe

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

 class NomClasse { public: NomClasse(type_parametre nom_parametre = valeur_par_defaut, type_parametre2 nom_parametre2 = valeur_par_defaut2); }; 

• Ici, le constructeur a 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 passée 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 constructeur avec arguments par défaut :

 #include <iostream> using namespace std; // Fonction avec un argument par défaut void afficherMessage(string message = "Bonjour, Apprenant Tutorialspoint") { cout << message << endl; } int main() { // Appel de la fonction sans argument afficherMessage(); // Affiche le message par défaut : "Bonjour, Apprenant Tutorialspoint" // Appel de la fonction avec un argument personnalisé afficherMessage("Salut, là !"); // Affiche le message personnalisé : "Salut, là !" return 0; } 

Sortie

 Bonjour, Apprenant Tutorialspoint Salut, là ! 

Explication

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

Constructeur avec plusieurs arguments par défaut

Un constructeur avec plusieurs arguments par défaut donne à l'utilisateur l'accès pour spécifier des valeurs par défaut pour plus d'un paramètre. Cela fournit plus de flexibilité et d'accès pour passer n'importe quelle combinaison d'arguments.

Exemple

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

 #include <iostream> using namespace std; class Boite { public: int longueur, largeur, hauteur; // Constructeur avec plusieurs arguments par défaut Boite(int l = 5, int w = 10, int h = 2) { // Valeurs par défaut pour longueur, largeur et hauteur longueur = l; largeur = w; hauteur = h; } void afficher() { cout << "Longueur: " << longueur << ", Largeur: " << largeur << ", Hauteur: " << hauteur << endl; } }; int main() { // Création d'objets avec différents nombres d'arguments Boite boite1; Boite boite2(15); Boite boite3(15, 20); Boite boite4(15, 20, 25); // Affichage des valeurs des objets boite1.afficher(); boite2.afficher(); boite3.afficher(); boite4.afficher(); return 0; } 

Sortie

 Longueur: 5, Largeur: 10, Hauteur: 2 Longueur: 15, Largeur: 10, Hauteur: 2 Longueur: 15, Largeur: 20, Hauteur: 2 Longueur: 15, Largeur: 20, Hauteur: 25 

Explication

• Premièrement, la classe Boite est définie avec trois variables membres publiques : longueur, largeur et hauteur, où le constructeur Boite(int l = 5, int w = 10, int h = 2) a des arguments par défaut pour les trois paramètres.
• Dans l'objet Boite boite1; aucun argument n'est fourni, donc le constructeur par défaut est appelé avec les valeurs par défaut, résultant en "Longueur: 5, Largeur: 10, Hauteur: 2".
• Dans Boite boite2(15); la longueur est fournie comme 15, mais la largeur et la hauteur ne sont pas fournies, donc il utilise les valeurs par défaut respectivement.
• Dans Boite boite3(15, 20); la longueur et la largeur sont fournies avec les valeurs 15 et 20 respectivement, donc cela remplacera les valeurs par défaut et donnera le résultat en conséquence.

Caractéristiques clés des constructeurs avec arguments par défaut

Bien que ce soit similaire aux fonctions régulières, cela fournit plus de flexibilité et de commodité lors de la création d'objets.

Ici dans ce qui suit, nous discuterons de toutes ses caractéristiques 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és quand aucun argument n'est fourni par l'appelant et permet plusieurs façons de créer un objet.

2. Éviter les surcharges multiples de constructeurs

Vous pourriez avoir besoin de surcharger le constructeur pour chaque combinaison d'arguments, ce qui rendrait 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 à valeurs par défaut, vous ne pouvez pas sauter les arguments par défaut au milieu une fois que vous commencez à fournir des défauts à partir de la droite.

Syntaxe

 Boite(int l = 1, int w); // Invalide : 'w' n'a pas de défaut, mais 'l' en a un. 

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

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

Syntaxe

 class Boite { public: const int longueur, largeur; Boite(int l = 5, int w = 10) : longueur(l), largeur(w) {} }; 

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