Constructor în C++ este o metodă specială care este invocată automat în momentul creării obiectului. Este folosit pentru a inițializa membrii de date ai obiectelor noi în general. Constructorul din C++ are același nume ca și clasa sau structura. Construiește valorile, adică furnizează date pentru obiect, motiv pentru care este cunoscut ca un constructor.
- Constructorul este o funcție membră a unei clase, al cărei nume este același cu numele clasei.
- Constructorul este un tip special de funcție membru care este utilizat pentru a inițializa membrii de date pentru un obiect al unei clase în mod automat atunci când este creat un obiect din aceeași clasă.
- Constructorul este invocat în momentul creării obiectului. Construiește valorile, adică furnizează date pentru obiect, de aceea este cunoscut ca un constructor.
- Constructorii nu returnează valoare, prin urmare nu au un tip de returnare.
- Un constructor este apelat automat când creăm obiectul clasei.
- Constructorii pot fi supraîncărcați.
- Un constructor nu poate fi declarat virtual.
Sintaxa constructorilor în C++
Prototipul constructorului arată astfel:
(list-of-parameters);>
Constructorul poate fi definit în interiorul declarației de clasă sau în afara declarației de clasă
Sintaxă pentru definirea constructorului în cadrul clasei
(list-of-parameters) { // constructor definition }> Sintaxă pentru definirea constructorului în afara clasei
: :(list-of-parameters) { // constructor definition }> Exemple de constructori în C++
Exemplele de mai jos demonstrează cum se declară constructori pentru o clasă în C++:
Exemplul 1: Definirea constructorului în cadrul clasei
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>> nume;> >cout <<>'Enter the Fee:'>;> >cin>> taxa;> >}> >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;> }> |
java string.format
>
>
Ieșire
Enter the RollNo:121 Enter the Name:Geeks Enter the Fee:5000 121 Geeks 5000>
Exemplul 2: Definirea constructorului în afara clasei
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>> nume;> >cout <<>'Enter the Fee:'>;> >cin>> taxa;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> // driver code> int> main()> {> >student s;> >s.display();> >return> 0;> }> |
>
>
Ieșire
Enter the RollNo:11 Enter the Name:Aman Enter the Fee:10111 11 Aman 10111>
Notă: Putem face constructorul definit în afara clasei ca în linie pentru a-l face echivalent cu definiția din clasă. Dar rețineți că în linie nu este o instrucțiune pentru compilator, este doar cererea pe care compilatorul o poate implementa sau nu, în funcție de circumstanțe.
Caracteristicile constructorilor în C++
Următoarele sunt câteva caracteristici principale ale constructorilor din C++:
- Numele constructorului este același cu numele clasei sale.
- Constructorii sunt declarați în mare parte în secțiunea publică a clasei, deși pot fi declarați în secțiunea privată a clasei.
- Constructorii nu returnează valori; prin urmare, nu au un tip de returnare.
- Un constructor este apelat automat când creăm obiectul clasei.
- Constructorii pot fi supraîncărcați.
- Un constructor nu poate fi declarat virtual.
- Un constructor nu poate fi moștenit.
- Nu se poate face referire la adresele Constructorului.
- Constructorul face apeluri implicite la nou și șterge operatori în timpul alocării memoriei.
Tipuri de constructori în C++
Constructorii pot fi clasificați în funcție de situațiile în care sunt utilizați. Există 4 tipuri de constructori în C++:
- Constructor implicit
- Constructor parametrizat
- Copie constructor
- Mutați constructorul
Să înțelegem tipurile de constructori din C++ luând un exemplu din lumea reală. Să presupunem că ai mers la un magazin să cumperi un marker. Când doriți să cumpărați un marker, care sunt opțiunile? Primul te duci la un magazin și spui dă-mi un marker. Așa că doar a spune dă-mi un marker înseamnă că nu ai setat ce nume de marcă și ce culoare, nu ai menționat nimic, ci ai spus că vrei un marker. Așa că, când am spus doar că vreau un marker, indiferent de marcatorul vândut frecvent este acolo în piață sau în magazinul lui, el va preda pur și simplu asta. Și asta este un constructor implicit!
A doua metodă este să mergi la un magazin și să spui că vreau un marker de culoare roșie și marca XYZ. Deci tu menționezi asta și el îți va da acel marker. Deci, în acest caz, ați dat parametrii. Și asta este un constructor parametrizat!
Apoi, al treilea, mergi la un magazin și spui că vreau un marker ca acesta (un marker fizic pe mâna ta). Deci comerciantul va vedea acel marcaj. Bine, și el va da un nou marker pentru tine. Deci copie a acelui marker. Și asta este un constructor de copiere!
Acum, presupuneți că nu doriți să cumpărați un marker nou, ci să vă ocupați de markerul prietenului dvs. Înseamnă să preluați proprietatea asupra resurselor deja prezente în loc să obțineți una nouă. Asta este un constructor de mutare!
1. Constructor implicit în C++
A constructor implicit este un constructor care nu acceptă niciun argument. Nu are parametri. Se mai numește și constructor cu argument zero.
Sintaxa constructorului implicit
className() { // body_of_constructor }> Exemple de constructor implicit
Exemplele de mai jos demonstrează cum să utilizați constructorii impliciti în C++.
Exemplul 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;> }> |
>
>Ieșire
a: 10 b: 20>
Notă: Chiar dacă nu definim niciun constructor în mod explicit, compilatorul va furniza automat un constructor implicit implicit.
Exemplul 2:
C++
// 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;> }> |
>
>
Ieșire
(no output)>
După cum putem vedea, putem crea obiectul clasei student fără a trece niciun argument chiar și atunci când nu am definit niciun constructor implicit implicit pentru acesta.
2. Constructor parametrizat în C++
Constructorii parametrizați fac posibilă transmiterea de argumente către constructori. De obicei, aceste argumente ajută la inițializarea unui obiect atunci când este creat. Pentru a crea un constructor parametrizat, pur și simplu adăugați parametri la el așa cum ați face-o pentru orice altă funcție. Când definiți corpul constructorului, utilizați parametrii pentru a inițializa obiectul.
Sintaxa constructorului parametrizat
className (parameters...) { // body }> Exemple de constructor parametrizat
Exemplele de mai jos demonstrează cum să utilizați constructorii parametrizați în C++.
Exemplul 1: Definirea constructorului parametrizat în interiorul clasei.
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;> }> |
>
>Ieșire
p1.x = 10, p1.y = 15>
Exemplul 2: Definirea constructorului parametrizat în afara clasei.
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;> }> |
>
>Ieșire
1001 Ram 10000>
Când un obiect este declarat într-un constructor parametrizat, valorile inițiale trebuie să fie transmise ca argumente funcției de constructor. Modul normal de declarare a obiectului poate să nu funcționeze. Constructorii parametrizați pot fi apelați explicit sau implicit:
Example e = Example(0, 50); // Explicit call Example e(0, 50); // Implicit call>
Când constructorul parametrizat este definit și niciun constructor implicit nu este definit în mod explicit, compilatorul nu va crea implicit constructorul implicit și, prin urmare, va crea un obiect simplu ca:
Student s;>
va clipi o eroare.
Exemplul 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;> }> |
>
>
Ieșire
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 ^~> Notă importantă: Ori de câte ori definim unul sau mai mulți constructori non-impliciți (cu parametri) pentru o clasă, un constructor implicit (fără parametri) ar trebui, de asemenea, definit în mod explicit, deoarece compilatorul nu va furniza un constructor implicit în acest caz. Cu toate acestea, nu este necesar, dar este considerată cea mai bună practică pentru a defini întotdeauna un constructor implicit.
Utilizări ale constructorului parametrizat
- Este folosit pentru a inițializa diferitele elemente de date ale diferitelor obiecte cu valori diferite atunci când sunt create.
- Este folosit pentru supraîncărcarea constructorilor.
Argumente implicite cu constructor parametrizat C++
La fel ca funcțiile normale, putem defini și valori implicite pentru argumentele constructorilor parametrizați. Toate regulile argumente implicite vor fi aplicate acestor parametri.
Exemplul 3: Definirea constructorului parametrizat cu valori implicite
C++
// 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;> }> |
>
>Ieșire
First Object Data: 0 Second Object Data: 25>
După cum putem vedea, atunci când valorile implicite sunt atribuite fiecărui argument al constructorului parametrizat, este legal să creați obiectul fără a trece niciun parametru la fel ca constructorii impliciti. Deci, acest tip de constructor funcționează atât ca un constructor implicit, cât și ca un constructor parametrizat.
3. Copiați constructorul în C++
Un constructor de copiere este o funcție membru care inițializează un obiect folosind un alt obiect din aceeași clasă.
Sintaxa lui Copie constructor
Constructor de copiere ia o referire la un obiect din aceeași clasă ca un argument.
ClassName (ClassName &obj) { // body_containing_logic }> La fel ca și constructorul implicit, compilatorul C++ oferă, de asemenea, un constructor de copiere implicit dacă definiția explicită a constructorului de copiere nu este prezentă. Aici, este de remarcat faptul că, spre deosebire de constructorul implicit, unde prezența oricărui tip de constructor explicit are ca rezultat ștergerea constructorului implicit implicit, constructorul implicit de copiere va fi întotdeauna creat de compilator dacă nu există un constructor de copie explicit. sau un constructor de mutare explicit este prezent.
Exemple de Copy Constructor
Exemplele de mai jos demonstrează cum să utilizați constructorii de copiere în C++.
Exemplul 1: Ilustrarea constructorului de copiere implicită
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;> }> |
>
>Ieșire
ID=10 ID=10>
Exemplul 2: Definirea constructorului de copiere explicită
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;> }> |
>
lista de utilizatori mysql
>Ieșire
ID=10 ID=10>
Exemplul 3: Definirea constructorului de copiere explicită cu constructor parametrizat
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;> }> |
>
>Ieșire
1001 Manjeet 10000 1001 Manjeet 10000>
Utilizări ale Copy Constructorului
- Construiește un obiect nou prin copierea valorilor dintr-un obiect existent.
- Poate fi folosit pentru a efectua copierea profundă.
- Modificați anumite atribute în timpul procesului de copiere, dacă este necesar.
4. Mutați constructorul în C++
Constructorul de mutare este o adăugare recentă la familia de constructori în C++. Este ca un constructor de copiere care construiește obiectul din obiectele deja existente, dar în loc să copieze obiectul în noua memorie, folosește semantica de mișcare pentru a transfera dreptul de proprietate asupra obiectului deja creat către noul obiect fără a crea un plus. copii.
Poate fi văzut ca furtul resurselor de la alte obiecte.
Sintaxa Move Constructor în C++
className (className&& obj) { // body of the constructor }> The muta constructor ia referință rvalue a obiectului aceleiași clase și transferă dreptul de proprietate asupra acestui obiect obiectului nou creat.
La fel ca un constructor de copiere, compilatorul va crea un constructor de mutare pentru fiecare clasă care nu are niciun constructor de mutare explicit.
Exemple de Move Constructor
Exemplele de mai jos demonstrează cum să utilizați constructorii de mutare în C++.
Exemplul 1: Definirea constructorului de mutare
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;> }> |
>
>Ieșire
Move Constructor Called newBox.data: 42>
Utilizări ale Move Constructor
- În loc să faci copii, constructorii de mutare transferă eficient dreptul de proprietate asupra acestor resurse.
- Acest lucru previne copierea inutile din memorie și reduce supraîncărcarea.
- Puteți defini propriul dvs. constructor de mișcare pentru a gestiona anumite transferuri de resurse.
Destructori în C++
Un destructor este, de asemenea, o funcție membru specială ca constructor. Destructor distruge obiectele de clasă create de constructor. Destructorul are același nume cu numele clasei lor precedat de un simbol tilde (~). Nu este posibil să definiți mai mult de un destructor. Destructorul este doar o modalitate de a distruge obiectul creat de constructor. Prin urmare, destructorul nu poate fi supraîncărcat. Destructorul nu necesită nici un argument și nici nu returnează nicio valoare. Este apelat automat atunci când obiectul iese din domeniul de aplicare. Destructorii eliberează spațiul de memorie ocupat de obiectele create de constructor. În distrugător , obiectele sunt distruse în reversul creării obiectului.
Sintaxa destructorilor în C++
Ca și constructorii, destructorii pot fi definiți fie în interiorul, fie în afara clasei.
Sintaxa pentru definirea destructorului în cadrul clasei
~ (){}> Sintaxa pentru definirea destructorului în afara clasei
: : ~(){}> Exemple de destructori în C++
Exemplele de mai jos demonstrează cum să folosiți destructorii în C++.
Exemplul 1: Definirea unui destructor simplu
C++
#include> using> namespace> std;> class> Test {> public>:> >Test() { cout <<>'
Constructor executed'>; }> >~Test() { cout <<>'
Destructor executed'>; }> };> main()> {> >Test t;> >return> 0;> }> |
>
>Ieșire
Constructor executed Destructor executed>
Exemplul 2: Numărarea numărului de ori când obiectul este creat și distrus
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;> }> |
>
>
Ieșire
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>
Caracteristicile Destructorilor în C++
Următoarele sunt câteva caracteristici principale ale destructorilor în C++:
- Destructorul este invocat automat de compilator atunci când constructorul său corespunzător iese din domeniul de aplicare și eliberează spațiul de memorie care nu mai este necesar programului.
- Destructorul nu necesită niciun argument și nici nu returnează nicio valoare, prin urmare nu poate fi supraîncărcat.
- Destructorul nu poate fi declarat ca static și const;
- Destructorul ar trebui să fie declarat în secțiunea publică a programului.
- Destructorul este apelat în ordinea inversă a invocării constructorului său.
Întrebări frecvente despre constructorii C++
Care sunt funcțiile care sunt generate de compilator în mod implicit, dacă nu le furnizăm în mod explicit?
Funcțiile care sunt generate de compilator în mod implicit dacă nu le furnizăm în mod explicit sunt:
- Constructor implicit
- Copie constructor
- Mutați constructorii
- Operator de atribuire
- Distrugător
Putem face constructorii privati?
Da, în C++, constructorii pot fi privați. Aceasta înseamnă că niciun cod extern nu poate crea direct un obiect din acea clasă.
Cum diferă constructorii de o funcție de membru normală?
Un constructor este diferit de funcțiile normale în următoarele moduri:
- Constructorul are același nume ca și clasa în sine
- Constructorii impliciti nu au argument de intrare, totuși, constructorii Copiere și parametrizați au argumente de intrare
- Constructorii nu au tip de returnare
- Un constructor este apelat automat atunci când este creat un obiect.
- Trebuie plasat în secțiunea publică a clasei.
- Dacă nu specificăm un constructor, compilatorul C++ generează un constructor implicit pentru obiect (nu se așteaptă la niciun parametri și are un corp gol).
Putem avea mai mult de un constructor într-o clasă?
Da, putem avea mai mult de un constructor într-o clasă. Se numeste Supraîncărcarea constructorului .
Articole similare:
- Destructori în C++
- Test despre constructori în C++
- Ieșirea programelor C++ | Setul 26 (Constructori)
- Ieșirea programelor C++ | Setul 27 (Constructori și destructori)