C++-constructors:standaardargumenten gebruiken voor het maken van flexibele objecten

Een constructor is een speciale lidfunctie in een klasse, die automatisch wordt aangeroepen wanneer een object wordt gemaakt. Deze worden gebruikt om het object te initialiseren met waarden of standaardinstellingen.

Terwijl standaardargumenten in C++ het mogelijk maken standaardwaarden te specificeren voor functie- of constructorparameters.

Constructor met standaardargumenten

Een constructor met standaardargumenten is een constructor waarmee een object kan worden gemaakt met behulp van optionele parameters. Waar de standaardwaarden voor de parameters worden opgegeven, dus als de gebruiker geen waarden doorgeeft, wordt de standaardwaarde gebruikt.

Syntaxis

Hier is de syntaxis voor de constructor met standaardargumenten:

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

• Hier heeft de constructor dezelfde naam als de klasse
• Er worden standaardwaarden opgegeven voor een of meer parameters.
• Als er geen waarde wordt doorgegeven door de gebruiker, wordt deze standaardwaarde gebruikt.

Voorbeeld van constructor met standaardargumenten

Hier is het volgende voorbeeld voor een constructor met standaardargumenten:

#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;
}

Uitvoer

Hello, Tutorialspoint Learner
Hi, there!

Uitleg

• Een functie printMessage() wordt gemaakt en geeft een parameter met de standaardwaarde "Hallo, Tutorialspoint Learner".
• Nu in main(), printMessage() functie wordt aangeroepen zonder enig argument, dus het standaardargument "Hallo, Tutorialspoint Learner" wordt gebruikt.
• terwijl in printMessage("Hallo daar!") , hebben we expliciet de waarde "Hallo daar!" dus dit overschrijft het standaardargument.

Constructor met meerdere standaardargumenten

Een constructor met meerdere standaardargumenten geeft de gebruiker toegang om standaardwaarden voor meer dan één parameter op te geven. Dit biedt meer flexibiliteit en toegang om elke combinatie van argumenten door te geven.

Voorbeeld

Hier is het volgende voorbeeld voor een constructor met meerdere standaardargumenten:

#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;
}

Uitvoer

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

Uitleg

• Ten eerste wordt de klassenbox gedefinieerd met drie publieke lidvariabelen:lengte en breedte, waarbij de constructor Box(int l =5, int w =10, int h =2) heeft standaardargumenten voor alle drie de parameters.
• In object Box box1; er wordt geen argument opgegeven, dus wordt de standaardconstructor aangeroepen met standaardwaarden, wat resulteert in "Lengte:5, Breedte:10, Hoogte:2".
• In Box box2(15); lengte wordt opgegeven als 15, maar breedte en hoogte worden niet opgegeven. Daarom worden respectievelijk de standaardwaarden gebruikt.
• In Box box3(15, 20); lengte en breedte zijn respectievelijk voorzien van de waarden 15 en 20, dus deze zullen de standaardwaarden overschrijven en dienovereenkomstig resulteren.

Belangrijkste kenmerken van constructors met standaardargumenten

Hoewel het vergelijkbaar is met reguliere functies, biedt het meer flexibiliteit en gemak bij het maken van objecten.

Hieronder bespreken we alle belangrijke kenmerken ervan.

1. Standaardwaarden voor parameters en flexibiliteit bij het maken van objecten

Hier kan de constructor standaardwaarden hebben voor een of meer parameters, die kunnen worden gebruikt als er geen argument wordt opgegeven door de aanroeper en meerdere manieren mogelijk maken om een object te maken.

2. Overbelasting van meerdere constructors voorkomen

Mogelijk moet u de constructor voor elke combinatie van argumenten laden, waardoor de code omvangrijker wordt, maar met standaardargumenten kan de constructor één keer worden geschreven en worden verschillende gevallen automatisch afgehandeld.

3. Volgorde van standaardargumenten

In het geval van meerdere standaardwaardeparameters kunt u de standaardargumenten in het midden niet overslaan zodra u vanaf de rechterkant begint met het opgeven van standaardwaarden.

Syntaxis

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

4. Standaardargumenten kunnen worden gebruikt bij Const-leden

Als uw klasse const-leden heeft, kunnen standaardargumenten in de constructor worden opgegeven om de initialisatie eenvoudiger te maken.

Syntaxis

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

Deze constructor gebruikt standaardargumenten (lengte =5 en breedte =10) om de const-leden te initialiseren.