Costruttore in C++

In questo articolo, imparerai i costruttori in C++. Imparerai cosa sono i costruttori, come crearli e i tipi di costruttori in C++.

Il costruttore è un tipo speciale di funzione membro che viene chiamato quando si creaoggettoViene inizializzato automaticamente

Il compilatore identifica la funzione membro data dal nome e dal tipo di ritorno come costruttore.

Il costruttore ha lo stesso nome della classe e non ha alcun tipo di ritorno. Allo stesso modo, il costruttore è sempre pubblico.

...　..　...
class temporary
{
private:　
　　　　int x;
　　　　float y;
public:
　　　　// Costruttore
　　　　temporary(): x(5), y(5.5)
　　　　{
　　　　　　　　// Corpo del costruttore
　　　　}
　　　　...　..　　...
};
int main()
{
　　　　Temporary t1;
　　　　...　..　...
}

Il programma sopra mostra il costruttore definito, senza tipo di ritorno e con il nome uguale alla classe.

Come funziona il costruttore?

Nel codice sopra, temporary() è un costruttore.

Quando si crea un oggetto della classe, viene automaticamente chiamato il costruttore temporary, che inizializza x a 5 e y a 5.5.

Puoi anche inizializzare i membri di dati all'interno del costruttore in questo modo. Tuttavia, questo metodo non è raccomandato.

temporary();
{
　　　x = 5;
　　　y = 5.5;
}
// Questo metodo non è il preferito.

Nella programmazione C++

Immagina di gestire 100 oggetti Person, e il membro di dati age ha un valore predefinito di 0. Inizializzare manualmente tutti gli oggetti sarà un compito molto noioso.

Di contro, è possibile definire un costruttore che inizializza age a 0. Poi, tutto ciò che devi fare è creare un oggetto Person, il costruttore inizializzerà automaticamente age.

Queste situazioni si verificano spesso quando si gestiscono array di oggetti.

Inoltre, se si desidera eseguire alcune istruzioni immediatamente dopo la creazione dell'oggetto, è possibile posizionare il codice nel corpo del costruttore.

Esempio 1: Metodi di costruzione in C++

Calcola e visualizza l'area del rettangolo.

#include <iostream>
using namespace std;
class Area
{
　　　　private:
　　　　　　　int length;
　　　　　　　int breadth;
　　　　public:
　　　　　　　// Costruttore
　　　　　　　Area(): length(5), breadth(2){}
　　　　　　　void GetLength()
　　　　　　　{
　　　　　　　　　　　cout << "Inserire rispettivamente la lunghezza e la larghezza: ";
　　　　　　　　　　　cin >> length >> breadth;
　　　　　　　}
　　　　　　　int AreaCalculation() { return (length * breadth); }
　　　　　　　void DisplayArea(int temp)
　　　　　　　{
　　　　　　　　　　　cout << "Area: " << temp;
　　　　　　　}
};
int main()
{
　　　　Area A1, A2;
　　　　int temp;
　　　　A1.GetLength();
　　　　temp = A1.AreaCalculation();
　　　　A1.DisplayArea(temp);
　　　　cout << endl << "L'area predefinita di default quando non si ricevono valori dall'utente è:" << endl;
　　　　temp = A2.AreaCalculation();
　　　　A2.DisplayArea(temp);
　　　　return 0;
}

In questo programma, viene creato la classe Area per gestire le funzioni relative all'area. Ha due membri dati length e breadth.

È stato definito un costruttore che inizializza length a 5 e breadth a 2.

Abbiamo anche tre funzioni membro aggiuntive GetLength(), AreaCalculation() e DisplayArea(), che rispettivamente ricevono la lunghezza dall'utente, calcolano l'area e visualizzano l'area.

Quando si creano gli oggetti A1 e A2, a causa della relazione del costruttore, le lunghezze (length) e le larghezze (breadth) di questi due oggetti vengono inizializzate rispettivamente a 5 e 2.

Poi, chiama la funzione membro GetLength(), che riceve i valori di lunghezza (length) e larghezza (breadth) dell'oggetto A1 dall'utente. Questo cambia la lunghezza (length) e la larghezza (breadth) dell'oggetto A1.

Poi, chiama la funzione AreaCalculation() per calcolare l'area dell'oggetto A1 e salvarla nella variabile temp, infine visualizzala.

Per l'oggetto A2, non è richiesto che l'utente fornisca alcun dato. Pertanto, la lunghezza (length) e la larghezza (breadth) sono mantenute rispettivamente 5 e 2.

Poi, calcola e visualizza l'area di A2 che è 10.

Risultato di output

Inserire rispettivamente la lunghezza e la larghezza: 6
7
Area: 42
L'area predefinita di default quando non si ricevono valori dall'utente è:
Area: 10

Sovraccarico del costruttore.

Il costruttore può essere simile a.Sovraccarico della funzione.Sovraccarico del metodo.

I costruttori sovraccaricati hanno lo stesso nome (il nome della classe), ma un numero diverso di parametri.

In base al numero e al tipo dei parametri passati, viene chiamato il costruttore specifico.

Poiché ci sono più costruttori, i parametri del costruttore devono anche essere passati durante la creazione dell'oggetto.

Esempio 2: Sovraccarico del costruttore

// Sorgente che dimostra il funzionamento del costruttore sovraccaricato
#include <iostream>
using namespace std;
class Area
{
　　　　private:
　　　　　　　int length;
　　　　　　　int breadth;
　　　　public:
　　　　　　　// Costruttore senza parametri
　　　　　　　Area(): length(5), breadth(2) { }
　　　　　　　// Costruttore con due parametri
　　　　　　　Area(int l, int b): length(l), breadth(b){ }
　　　　　　　void GetLength()
　　　　　　　{
　　　　　　　　　　　cout << "Inserisci lunghezza e larghezza: ";
　　　　　　　　　　　cin >> length >> breadth;
　　　　　　　}
　　　　　　　int AreaCalculation() { return length * breadth; }
　　　　　　　void DisplayArea(int temp)
　　　　　　　{
　　　　　　　　　　　cout << "Area: " << temp << endl;
　　　　　　　}
};
int main()
{
　　　　Area A1, A2(2, 1);
　　　　int temp;
　　　　cout << "L'area predefinita senza passare parametri." << endl;
　　　　temp = A1.AreaCalculation();
　　　　A1.DisplayArea(temp);
　　　　cout << "L'area quando si passa come parametro (2,1)." << endl;
　　　　temp = A2.AreaCalculation();
　　　　A2.DisplayArea(temp);
　　　　return 0;
}

Per l'oggetto A1, non vengono passati parametri durante la creazione dell'oggetto.

Pertanto, verrà chiamato il costruttore senza parametri, che inizializza la lunghezza (length) a 5 e la larghezza (breadth) a 2. Pertanto, l'area dell'oggetto A1 sarà 10.

Per l'oggetto A2, vengono passati come parametri 2 e 1 durante la creazione dell'oggetto.

Pertanto, verrà chiamato il costruttore con due parametri, che inizializza la lunghezza (length) a l (in questo caso 2) e la larghezza (breadth) a b (in questo caso 1). Pertanto, l'area dell'oggetto A2 sarà 2.

Risultato di output

L'area predefinita senza passare parametri.
Area: 10
L'area quando si passa come parametro (2,1).
Area: 2

Costruttore di copia predefinito

Un oggetto può essere inizializzato con un altro oggetto dello stesso tipo. Questo è lo stesso che copiare i contenuti di una classe in un'altra classe.

Nel programma sopra, se desideri inizializzare un oggetto A3 in modo che contenga lo stesso valore di A2, puoi eseguire così:

....
int main()
{
　　　Area A1, A2(2, 1);
　　　// Copiare il contenuto di A2 in A3
　　　Area A3(A2);
　　　　　OR,　
　　　Area A3 = A2;
}

Potrebbe sembrare che debba creare un nuovo costruttore per eseguire questa attività. Tuttavia, non è necessario un costruttore aggiuntivo. Questo è perché il costruttore di copia è già integrato in tutti i tipi di classe di default.