C++ Constructors: Standaardargumenten Gebruiken voor Flexibele Objectcreatie

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

Waarbij standaardargumenten in C++ toestaan om standaardwaarden op te geven voor functie- of constructorparameters.

Constructor met Standaardargumenten

Een constructor met standaardargumenten is een constructor die het mogelijk maakt om een object te creëren met optionele parameters. Waarbij standaardwaarden voor de parameters worden opgegeven, zodat wanneer de gebruiker geen waarden doorgeeft, de standaardwaarde wordt gebruikt.

Syntaxis

Hier is de syntaxis gegeven 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
• Standaardwaarden worden opgegeven voor een of meer parameters.
• Als de gebruiker geen waarde doorgeeft, wordt deze standaardwaarde gebruikt.

Voorbeeld van Constructor met Standaardargumenten

Hier is het volgende voorbeeld voor constructor met standaardargumenten:

#include <iostream>
using namespace std;
// Functie met een standaardargument
void printMessage(string message = "Hello, Tutorialspoint Learner") {
    cout << message << endl;
}
int main() {
    // Functie aanroepen zonder argument
    printMessage(); // Print standaardbericht: "Hello, Tutorialspoint Learner"
    // Functie aanroepen met een aangepast argument
    printMessage("Hi, there!"); // Print aangepast bericht: "Hi, there!"
    return 0;
}

Uitvoer

Hello, Tutorialspoint Learner
Hi, there!

Uitleg

• Een functie printMessage() wordt gemaakt met een parameter met de standaardwaarde "Hello, Tutorialspoint Learner".
• Nu in main(), wordt de printMessage() functie aangeroepen zonder argument, dus de standaardargument "Hello, Tutorialspoint Learner" wordt gebruikt.
• Waarbij in printMessage("Hi, there!") expliciet de waarde "Hi, there!" wordt doorgegeven, dus dit overschrijft het standaardargument.

Constructor met Meerdere Standaardargumenten

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

Voorbeeld

Hier is het volgende voorbeeld voor constructor met meerdere standaardargumenten:

#include <iostream>
using namespace std;
class Box {
public:
    int length, width, height;
    // Constructor met meerdere standaardargumenten
    Box(int l = 5, int w = 10, int h = 2) {
        // Standaardwaarden voor lengte, breedte en hoogte
        length = l;
        width = w;
        height = h;
    }
    void display() {
        cout << "Lengte: " << length << ", Breedte: " << width << ", Hoogte: " << height << endl;
    }
};
int main() {
    // Objecten maken met verschillende aantallen argumenten
    Box box1;
    Box box2(15);
    Box box3(15, 20);
    Box box4(15, 20, 25);
    // Waarden van objecten tonen
    box1.display();
    box2.display();
    box3.display();
    box4.display();
    return 0;
}

Uitvoer

Lengte: 5, Breedte: 10, Hoogte: 2
Lengte: 15, Breedte: 10, Hoogte: 2
Lengte: 15, Breedte: 20, Hoogte: 2
Lengte: 15, Breedte: 20, Hoogte: 25

Uitleg

• Eerst wordt de klasse box gedefinieerd met drie publieke lidvariabelen: lengte en breedte, waar de constructor Box(int l = 5, int w = 10, int h = 2) standaardargumenten heeft voor alle drie parameters.
• In object Box box1; wordt geen argument opgegeven, dus de standaardconstructor wordt aangeroepen met standaardwaarden, resulterend in "Lengte: 5, Breedte: 10, Hoogte: 2".
• In Box box2(15); wordt lengte opgegeven als 15, maar breedte en hoogte niet, dus de standaardwaarden worden respectievelijk gebruikt.
• In Box box3(15, 20); worden lengte en breedte opgegeven met waarden 15 en 20 respectievelijk, dus de standaardwaarden worden overschreven en het resultaat is dienovereenkomstig.

Belangrijkste Kenmerken van Constructors met Standaardargumenten

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

Hier bespreken we alle belangrijke kenmerken.

1. Standaardwaarden voor parameters en flexibiliteit in objectcreatie

De constructor kan standaardwaarden hebben voor een of meer parameters, die gebruikt kunnen worden wanneer geen argument wordt doorgegeven door de aanroeper en stelt meerdere manieren in om een object te creëren.

2. Vermijden van meerdere constructor overloads

U moet misschien de constructor overladen voor elke combinatie van argumenten, wat de code bulkier maakt, maar met standaardargumenten kan de constructor één keer geschreven worden en zal het verschillende gevallen automatisch afhandelen.

3. Volgorde van Standaardargumenten

In het geval van meerdere standaardwaarde parameters, kunt u geen standaardargumenten in het midden overslaan zodra u begint met het verstrekken van standaarden vanaf rechts.

Syntaxis

Box(int l = 1, int w); // Ongeldig: 'w' heeft geen standaard, maar 'l' wel.

4. Standaardargumenten Kunnen Gebruikt Worden met Const Leden

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

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.