logo

TechCodeview

Costruttori in C++

Costruttore in C++ è un metodo speciale che viene richiamato automaticamente al momento della creazione dell'oggetto. Viene utilizzato generalmente per inizializzare i membri dati di nuovi oggetti. Il costruttore in C++ ha lo stesso nome della classe o della struttura. Costruisce i valori, ovvero fornisce dati per l'oggetto, motivo per cui è noto come costruttore.

  • Il costruttore è una funzione membro di una classe, il cui nome è uguale al nome della classe.
  • Il costruttore è un tipo speciale di funzione membro utilizzata per inizializzare automaticamente i membri dati per un oggetto di una classe quando viene creato un oggetto della stessa classe.
  • Il costruttore viene richiamato al momento della creazione dell'oggetto. Costruisce i valori, ovvero fornisce dati per l'oggetto, motivo per cui è noto come costruttore.
  • I costruttori non restituiscono valore, quindi non hanno un tipo restituito.
  • Un costruttore viene chiamato automaticamente quando creiamo l'oggetto della classe.
  • I costruttori possono essere sovraccaricati.
  • Un costruttore non può essere dichiarato virtuale.

Sintassi dei costruttori in C++

Il prototipo del costruttore è simile al seguente:

 (list-of-parameters);>

Il costruttore può essere definito all'interno della dichiarazione della classe o all'esterno della dichiarazione della classe



Sintassi per definire il costruttore all'interno della classe 

 (list-of-parameters) {     // constructor definition  }>

Sintassi per definire il costruttore all'esterno della classe 

: :(list-of-parameters) {    // constructor definition  }>

Esempi di costruttori in C++

Gli esempi seguenti dimostrano come dichiarare i costruttori per una classe in C++:

Esempio 1: definizione del costruttore all'interno della classe

C++




// defining the constructor within the class> #include> using> namespace> std;> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >// constructor> >student()> >{> >cout <<>'Enter the RollNo:'>;> >cin>>rno;> >cout <<>'Enter the Name:'>;> >cin>> nome;> >cout <<>'Enter the Fee:'>;> >cin>> tariffa;> >}> >void> display()> >{> >cout << endl << rno <<>' '> << name <<>' '> << fee;> >}> };> int> main()> {> >student s;>// constructor gets called automatically when> >// we create the object of the class> >s.display();> >return> 0;> }> 

>

>

Produzione 

Enter the RollNo:121 Enter the Name:Geeks Enter the Fee:5000 121 Geeks 5000>

Esempio 2: definizione del costruttore esterno alla classe

C++




// defining the constructor outside the class> #include> using> namespace> std;> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >// constructor declaration only> >student();> >void> display();> };> // outside definition of constructor> student::student()> {> >cout <<>'Enter the RollNo:'>;> >cin>>rno;> >cout <<>'Enter the Name:'>;> >cin>> nome;> >cout <<>'Enter the Fee:'>;> >cin>> tariffa;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> // driver code> int> main()> {> >student s;> >s.display();> >return> 0;> }> 

>

>

Produzione 

Enter the RollNo:11 Enter the Name:Aman Enter the Fee:10111 11 Aman 10111>

Nota: Possiamo rendere il costruttore definito all'esterno della classe come in linea per renderlo equivalente alla definizione in classe. Ma notalo in linea non è un'istruzione per il compilatore, è solo la richiesta che il compilatore può o meno implementare a seconda delle circostanze.

Caratteristiche dei costruttori in C++

Di seguito sono riportate alcune caratteristiche principali dei costruttori in C++:

  • Il nome del costruttore è lo stesso del nome della classe.
  • I costruttori sono per lo più dichiarati nella sezione pubblica della classe sebbene possano essere dichiarati nella sezione privata della classe.
  • I costruttori non restituiscono valori; quindi non hanno un tipo restituito.
  • Un costruttore viene chiamato automaticamente quando creiamo l'oggetto della classe.
  • I costruttori possono essere sovraccaricati.
  • Un costruttore non può essere dichiarato virtuale.
  • Un costruttore non può essere ereditato.
  • Gli indirizzi del Costruttore non sono riferibili.
  • Il costruttore effettua chiamate implicite a nuovo E eliminare operatori durante l'allocazione della memoria.

Tipi di costruttori in C++

I costruttori possono essere classificati in base alle situazioni in cui vengono utilizzati. In C++ esistono 4 tipi di costruttori:

  1. Costruttore predefinito
  2. Costruttore parametrizzato
  3. Copia costruttore
  4. Sposta costruttore

Cerchiamo di comprendere i tipi di costruttori in C++ prendendo un esempio del mondo reale. Supponiamo che tu sia andato in un negozio per comprare un pennarello. Quando vuoi acquistare un pennarello, quali sono le opzioni? Il primo vai in un negozio e dici dammi un pennarello. Quindi solo dire dammi un pennarello significa che non hai impostato quale marca e quale colore, non hai menzionato nulla, hai solo detto che vuoi un pennarello. Quindi, quando abbiamo detto solo 'Voglio un pennarello', qualunque sia il pennarello venduto di frequente presente nel mercato o nel suo negozio, lo consegnerà semplicemente. E questo è ciò che è un costruttore predefinito!

Il secondo metodo è andare in un negozio e dire che voglio un pennarello di colore rosso e della marca XYZ. Quindi stai menzionando questo e lui ti darà quel pennarello. Quindi in questo caso hai fornito i parametri. E questo è ciò che è un costruttore parametrizzato!

Poi il terzo vai in un negozio e dici Voglio un pennarello come questo (un pennarello fisico sulla tua mano). Quindi il negoziante vedrà quell'indicatore. Ok, e ti darà un nuovo pennarello. Quindi copia di quel pennarello. E questo è ciò che è un costruttore di copie!

Ora, supponi di non acquistare un nuovo segnalino ma di assumere invece la proprietà del segnalino del tuo amico. Significa appropriarsi delle risorse già presenti invece di acquisirne di nuove. Questo è ciò che è un costruttore di mosse!

1. Costruttore predefinito in C++

UN costruttore predefinito è un costruttore che non accetta alcun argomento. Non ha parametri. È anche chiamato costruttore con argomenti zero.

Sintassi del costruttore predefinito 

className() {     // body_of_constructor  }>

Esempi di costruttore predefinito

Gli esempi seguenti dimostrano come utilizzare i costruttori predefiniti in C++.

Esempio 1:

CPP




// C++ program to illustrate the concept of default> // constructors> #include> using> namespace> std;> class> construct {> public>:> >int> a, b;> >// Default Constructor> >construct()> >{> >a = 10;> >b = 20;> >}> };> int> main()> {> >// Default constructor called automatically> >// when the object is created> >construct c;> >cout <<>'a: '> << c.a << endl <<>'b: '> << c.b;> >return> 1;> }> 

>

>

Produzione 

a: 10 b: 20>

Nota: Anche se non definiamo esplicitamente alcun costruttore, il compilatore fornirà automaticamente un costruttore predefinito in modo implicito.

Esempio 2:

C++

suite di strumenti primaverili




// C++ program to demonstrate the implicit default> // constructor> #include> using> namespace> std;> // class> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> };> int> main()> {> >// creating object without any parameters> >student s;> >return> 0;> }> 

>

>

Produzione 

(no output)>

Come possiamo vedere, siamo in grado di creare l'oggetto della classe student senza passare alcun argomento anche quando non abbiamo definito alcun costruttore predefinito esplicito per esso.

2. Costruttore con parametri in C++

I costruttori parametrizzati consentono di passare argomenti ai costruttori. In genere, questi argomenti aiutano a inizializzare un oggetto quando viene creato. Per creare un costruttore parametrizzato, aggiungi semplicemente parametri come faresti con qualsiasi altra funzione. Quando definisci il corpo del costruttore, usa i parametri per inizializzare l'oggetto.

Sintassi del costruttore parametrizzato 

className (parameters...) {     // body  }>

Esempi di costruttore parametrizzato

Negli esempi seguenti viene illustrato come utilizzare i costruttori con parametri in C++.

Esempio 1: definizione di un costruttore con parametri all'interno della classe.

CPP




// CPP program to illustrate parameterized constructors> #include> using> namespace> std;> class> Point {> private>:> >int> x, y;> public>:> >// Parameterized Constructor> >Point(>int> x1,>int> y1)> >{> >x = x1;> >y = y1;> >}> >int> getX() {>return> x; }> >int> getY() {>return> y; }> };> int> main()> {> >// Constructor called> >Point p1(10, 15);> >// Access values assigned by constructor> >cout <<>'p1.x = '> << p1.getX()> ><<>', p1.y = '> << p1.getY();> >return> 0;> }> 

>

>

Produzione 

p1.x = 10, p1.y = 15>

Esempio 2: definizione di un costruttore con parametri esterno alla classe.

C++




// C++ Program to illustrate how to define the parameterized> // constructor outside the class> #include> #include> using> namespace> std;> // class definition> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >student(>int>,>char>[],>double>);> >void> display();> };> // parameterized constructor outside class> student::student(>int> no,>char> n[],>double> f)> {> >rno = no;> >strcpy>(name, n);> >fee = f;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> // driver code> int> main()> {> >student s(1001,>'Ram'>, 10000);> >s.display();> >return> 0;> }> 

>

>

Produzione 

1001 Ram 10000>

Quando un oggetto viene dichiarato in un costruttore parametrizzato, i valori iniziali devono essere passati come argomenti alla funzione di costruzione. Il modo normale di dichiarazione dell'oggetto potrebbe non funzionare. I costruttori parametrizzati possono essere chiamati esplicitamente o implicitamente:

Example e = Example(0, 50);   // Explicit call  Example e(0, 50);    // Implicit call>

Quando il costruttore con parametri è definito e nessun costruttore predefinito è definito esplicitamente, il compilatore non creerà implicitamente il costruttore predefinito e quindi creerà un oggetto semplice come:

Student s;>

lampeggerà un errore.

Esempio 3:

C++




// C++ Program to illustrate the error caused be not> // defining the explicit defualt constructor after> // parameterized constructor> #include> #include> using> namespace> std;> // class definition> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >student(>int> no,>char> n[],>double> f)> >{> >rno = no;> >strcpy>(name, n);> >fee = f;> >}> };> // driver code> int> main()> {> >student s;>// this will cause error> >return> 0;> }> 

>

>

Produzione 

main.cpp: In function ‘int main()’: main.cpp:25:13: error: no matching function for call to ‘student::student()’  25 | student s; // this will cause error  | ^ main.cpp:14:5: note: candidate: ‘student::student(int, char*, double)’  14 | student(int no, char n[], double f)  | ^~~~~~~ main.cpp:14:5: note: candidate expects 3 arguments, 0 provided main.cpp:8:7: note: candidate: ‘constexpr student::student(const student&)’  8 | class student {  | ^~~~~~~ main.cpp:8:7: note: candidate expects 1 argument, 0 provided main.cpp:8:7: note: candidate: ‘constexpr student::student(student&&)’ main.cpp:8:7: note: candidate expects 1 argument, 0 provided ^~>

Nota importante: Ogni volta che definiamo uno o più costruttori non predefiniti (con parametri) per una classe, anche un costruttore predefinito (senza parametri) dovrebbe essere definito esplicitamente poiché in questo caso il compilatore non fornirà un costruttore predefinito. Tuttavia, non è necessario, ma è considerata la pratica migliore definire sempre un costruttore predefinito.

Usi del costruttore parametrizzato

  • Viene utilizzato per inizializzare i vari elementi dati di oggetti diversi con valori diversi quando vengono creati.
  • Viene utilizzato per sovraccaricare i costruttori.

Argomenti predefiniti con costruttore con parametri C++

Proprio come le normali funzioni, possiamo anche definire valori predefiniti per gli argomenti dei costruttori parametrizzati. Tutte le regole del argomenti predefiniti verrà applicato a questi parametri.

Esempio 3: definizione di un costruttore parametrizzato con valori predefiniti

C++


utenti dell'elenco mysql



// C++ Program to illustrate how to use default arguments> // with parameterized constructor> #include> using> namespace> std;> // class> class> GFG {> private>:> >int> data;> public>:> >// parameterized constructor with default values> >GFG(>int> x = 0) { data = x; }> >int> getData() {>return> data; }> };> int> main()> {> >GFG obj1;>// will not throw error> >GFG obj2(25);> >cout <<>'First Object Data: '> << obj1.getData() << endl;> >cout <<>'Second Object Data: '> << obj2.getData()> ><< endl;> >return> 0;> }> 

>

>

Produzione 

First Object Data: 0 Second Object Data: 25>

Come possiamo vedere, quando i valori predefiniti vengono assegnati a ogni argomento del costruttore parametrizzato, è legale creare l'oggetto senza passare alcun parametro proprio come i costruttori predefiniti. Pertanto, questo tipo di costruttore funziona sia come costruttore predefinito che con parametri.

3. Copia costruttore in C++

Un costruttore di copie è una funzione membro che inizializza un oggetto utilizzando un altro oggetto della stessa classe.

Sintassi di Copia costruttore

Copia costruttore accetta come argomento un riferimento a un oggetto della stessa classe.

ClassName (ClassName &obj) {    // body_containing_logic  }>

Proprio come il costruttore predefinito, anche il compilatore C++ fornisce un costruttore di copia implicito se la definizione del costruttore di copia esplicita non è presente. Qui, è da notare che, a differenza del costruttore predefinito in cui la presenza di qualsiasi tipo di costruttore esplicito comporta la cancellazione del costruttore predefinito implicito, il costruttore di copia implicita verrà sempre creato dal compilatore se non esiste un costruttore di copia esplicito o è presente un costruttore di mosse esplicito.

Esempi di costruttore di copie

Gli esempi seguenti dimostrano come utilizzare i costruttori di copia in C++.

Esempio 1: illustrazione del costruttore di copia implicita

C++




// C++ program to illustrate the use of Implicit copy> // constructor> #include> using> namespace> std;> class> Sample {> >int> id;> public>:> >// parameterized constructor> >Sample(>int> x) { id = x; }> >void> display() { cout <<>'ID='> << id; }> };> int> main()> {> >Sample obj1(10);> >obj1.display();> >cout << endl;> >// creating an object of type Sample from the obj> >Sample obj2(obj1);>// or obj2=obj1;> >obj2.display();> >return> 0;> }> 

>

>

Produzione 

ID=10 ID=10>

Esempio 2: definizione del costruttore di copia esplicita

C++




// C++ Program to demonstrate how to define the explicit> // copy constructor> #include> using> namespace> std;> class> Sample {> >int> id;> public>:> >// default constructor with empty body> >Sample() {}> >// parameterized constructor> >Sample(>int> x) { id = x; }> >// copy constructor> >Sample(Sample& t) { id = t.id; }> >void> display() { cout <<>'ID='> << id; }> };> // driver code> int> main()> {> >Sample obj1(10);> >obj1.display();> >cout << endl;> >// copy constructor called> >Sample obj2(obj1);>// or obj2=obj1;> >obj2.display();> >return> 0;> }> 

>

>

Produzione 

ID=10 ID=10>

Esempio 3: definizione del costruttore di copia esplicita con costruttore parametrizzato

C++




// C++ program to demonstrate copy construction along with> // parameterized constructor> #include> #include> using> namespace> std;> // class definition> class> student {> >int> rno;> >char> name[50];> >double> fee;> public>:> >student(>int>,>char>[],>double>);> >student(student& t)>// copy constructor> >{> >rno = t.rno;> >strcpy>(name, t.name);> >fee = t.fee;> >}> >void> display();> };> student::student(>int> no,>char> n[],>double> f)> {> >rno = no;> >strcpy>(name, n);> >fee = f;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> int> main()> {> >student s(1001,>'Manjeet'>, 10000);> >s.display();> >student manjeet(s);>// copy constructor called> >manjeet.display();> >return> 0;> }> 

>

>

Produzione 

1001 Manjeet 10000 1001 Manjeet 10000>

Usi del costruttore di copia

  • Costruisce un nuovo oggetto copiando i valori da un oggetto esistente.
  • Può essere utilizzato per eseguire una copia approfondita.
  • Se necessario, modifica attributi specifici durante il processo di copia.

4. Sposta il costruttore in C++

Il costruttore move è una recente aggiunta alla famiglia di costruttori in C++. È come un costruttore di copie che costruisce l'oggetto dagli oggetti già esistenti, ma invece di copiare l'oggetto nella nuova memoria, utilizza la semantica di spostamento per trasferire la proprietà dell'oggetto già creato al nuovo oggetto senza creare ulteriori oggetti. copie.

Può essere visto come un furto di risorse da altri oggetti.

Sintassi del costruttore Move in C++

className (className&& obj) {    // body of the constructor  }>

IL spostare il costruttore prende il riferimento del valore dell'oggetto della stessa classe e trasferisce la proprietà di questo oggetto all'oggetto appena creato.

Come un costruttore di copie, il compilatore creerà un costruttore di mosse per ogni classe che non ha alcun costruttore di mosse esplicito.

Esempi di costruttore di mosse

Gli esempi seguenti dimostrano come utilizzare i costruttori di spostamento in C++.

Esempio 1: definizione del costruttore di movimento

C++




// C++ Program to illustrate how to define a move> // constructor> #include> using> namespace> std;> class> Box {> public>:> >int>* data;>// Pointer to an integer value> >// Constructor> >Box(>int> value)> >{> >data =>new> int>;> >*data = value;> >}> >// Move constructor> >Box(Box&& other) noexcept> >{> >cout <<>'Move Constructor Called'> << endl;> >data = other.data;>// Transfer ownership of 'other'> >// data> >other.data = nullptr;>// Null out 'other' to prevent> >// double deletion> >}> >// Destructor> >~Box() {>delete> data; }> };> int> main()> {> >// Create a Box with value 42> >Box originalBox(42);> >// Create a new Box by moving resources from the> >// originalBox> >Box newBox(move(originalBox));> >cout <<>'newBox.data: '> << *newBox.data;> >// originalBox is now in a valid but unspecified> >// state (its resources were moved to newBox)> >return> 0;> }> 

>

elenco di array in Java 

>

Produzione 

Move Constructor Called newBox.data: 42>

Usi del costruttore di movimenti

  • Invece di creare copie, i costruttori di spostamento trasferiscono in modo efficiente la proprietà di queste risorse.
  • Ciò impedisce la copia non necessaria della memoria e riduce il sovraccarico.
  • È possibile definire il proprio costruttore di movimenti per gestire trasferimenti di risorse specifiche.

Distruttori in C++

Un distruttore è anche una funzione membro speciale come costruttore. Il distruttore distrugge gli oggetti della classe creati dal costruttore. Il distruttore ha lo stesso nome del nome della classe preceduto da un simbolo tilde (~). Non è possibile definire più di un distruttore. Il distruttore è solo un modo per distruggere l'oggetto creato dal costruttore. Quindi il distruttore non può essere sovraccaricato. Il distruttore non richiede alcun argomento né restituisce alcun valore. Viene chiamato automaticamente quando l'oggetto esce dall'ambito. I distruttori rilasciano lo spazio di memoria occupato dagli oggetti creati dal costruttore. In distruttore , gli oggetti vengono distrutti nel modo inverso rispetto alla creazione dell'oggetto.

Sintassi dei distruttori in C++

Come i costruttori, anche i distruttori possono essere definiti all'interno o all'esterno della classe.

La sintassi per definire il distruttore all'interno della classe 

~ (){}>

La sintassi per definire il distruttore all'esterno della classe 

: : ~(){}>

Esempi di distruttori in C++

Gli esempi seguenti dimostrano come utilizzare i distruttori in C++.

Esempio 1: definizione di un distruttore semplice

C++




#include> using> namespace> std;> class> Test {> public>:> >Test() { cout <<>' Constructor executed'>; }> >~Test() { cout <<>' Destructor executed'>; }> };> main()> {> >Test t;> >return> 0;> }> 

>

>

Produzione 

 Constructor executed Destructor executed>

Esempio 2: conteggio del numero di volte in cui l'oggetto viene creato e distrutto

C++




// C++ Program to count the number of objects created and> // destroyed> #include> using> namespace> std;> // global variable to count> int> count = 0;> // class definition> class> Test {> public>:> >Test()> >{> >count++;> >cout <<>'No. of Object created: '> << count << endl;> >}> >~Test()> >{> >cout <<>'No. of Object destroyed: '> << count> ><< endl;> >--count;> >}> };> // driver code> int> main()> {> >Test t, t1, t2, t3;> >return> 0;> }> 

>

>

Produzione 

No. of Object created: 1 No. of Object created: 2 No. of Object created: 3 No. of Object created: 4 No. of Object destroyed: 4 No. of Object destroyed: 3 No. of Object destroyed: 2 No. of Object destroyed: 1>

Caratteristiche dei distruttori in C++

Di seguito sono riportate alcune caratteristiche principali dei distruttori in C++:

  • Il distruttore viene richiamato automaticamente dal compilatore quando il costruttore corrispondente esce dall'ambito e rilascia lo spazio di memoria che non è più richiesto dal programma.
  • Il distruttore non richiede alcun argomento né restituisce alcun valore, pertanto non può essere sovraccaricato.
  • Il distruttore non può essere dichiarato come statico e const;
  • Il distruttore dovrebbe essere dichiarato nella sezione pubblica del programma.
  • Il distruttore viene chiamato nell'ordine inverso rispetto alla chiamata del costruttore.

Domande frequenti sui costruttori C++

Quali sono le funzioni generate dal compilatore per impostazione predefinita, se non le forniamo esplicitamente?

Le funzioni che vengono generate dal compilatore per impostazione predefinita se non le forniamo esplicitamente sono:

  1. Costruttore predefinito
  2. Copia costruttore
  3. Sposta costruttori
  4. Operatore di assegnazione
  5. Distruttore

Possiamo rendere privati ​​i costruttori?

Sì, in C++ i costruttori possono essere resi privati. Ciò significa che nessun codice esterno può creare direttamente un oggetto di quella classe.

In che modo i costruttori sono diversi da una normale funzione membro?

Un costruttore è diverso dalle normali funzioni nei seguenti modi:

  • Il costruttore ha lo stesso nome della classe stessa
  • I costruttori predefiniti non hanno argomenti di input, tuttavia, i costruttori Copia e Parametrizzati hanno argomenti di input
  • I costruttori non hanno un tipo restituito
  • Un costruttore viene chiamato automaticamente quando viene creato un oggetto.
  • Deve essere collocato nella sezione pubblica della classe.
  • Se non specifichiamo un costruttore, il compilatore C++ genera un costruttore predefinito per l'oggetto (non prevede parametri e ha un corpo vuoto).

Possiamo avere più di un costruttore in una classe?

Sì, possiamo avere più di un costruttore in una classe. È chiamato Sovraccarico del costruttore .

Articoli Correlati:

  • Distruttori in C++
  • Quiz sui costruttori in C++
  • Output di programmi C++ | Set 26 (Costruttori)
  • Output di programmi C++ | Set 27 (Costruttori e distruttori)