logo

TechCodeview

Constructeurs in C++

Constructeur in C++ is een speciale methode die automatisch wordt aangeroepen op het moment dat het object wordt gemaakt. Het wordt in het algemeen gebruikt om de gegevensleden van nieuwe objecten te initialiseren. De constructor in C++ heeft dezelfde naam als de klasse of structuur. Het construeert de waarden, d.w.z. levert gegevens voor het object en daarom staat het bekend als een constructor.

  • Constructor is een lidfunctie van een klasse, waarvan de naam hetzelfde is als de klassenaam.
  • Constructor is een speciaal type lidfunctie die wordt gebruikt om de gegevensleden voor een object van een klasse automatisch te initialiseren wanneer een object van dezelfde klasse wordt gemaakt.
  • Constructor wordt aangeroepen op het moment dat het object wordt gemaakt. Het construeert de waarden, d.w.z. levert gegevens voor het object en daarom staat het bekend als een constructor.
  • Constructors retourneren geen waarde en hebben daarom geen retourtype.
  • Een constructor wordt automatisch aangeroepen wanneer we het object van de klasse maken.
  • Constructeurs kunnen overbelast raken.
  • Een constructor kan niet virtueel worden verklaard.

Syntaxis van constructeurs in C++

Het prototype van de constructor ziet er als volgt uit:

 (list-of-parameters);>

De constructor kan binnen de klassendeclaratie of buiten de klassendeclaratie worden gedefinieerd



Syntaxis voor het definiëren van de constructor binnen de klasse 

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

Syntaxis voor het definiëren van de constructor buiten de klasse 

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

Voorbeelden van constructeurs in C++

De onderstaande voorbeelden laten zien hoe constructors voor een klasse in C++ worden gedeclareerd:

Voorbeeld 1: De constructor binnen de klasse definiëren

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>> naam;> >cout <<>'Enter the Fee:'>;> >cin>> vergoeding;> >}> >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;> }> 

>

>

Uitvoer 

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

Voorbeeld 2: De constructor buiten de klasse definiëren

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>> naam;> >cout <<>'Enter the Fee:'>;> >cin>> vergoeding;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> // driver code> int> main()> {> >student s;> >s.display();> >return> 0;> }> 

>

kali linux-opdrachten 

>

Uitvoer 

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

Opmerking: We kunnen de constructor buiten de klasse definiëren als in lijn om het gelijkwaardig te maken aan de in-class-definitie. Maar let op in lijn is geen instructie voor de compiler, het is alleen het verzoek dat de compiler wel of niet kan implementeren, afhankelijk van de omstandigheden.

Kenmerken van constructeurs in C++

Hieronder volgen enkele hoofdkenmerken van de constructors in C++:

  • De naam van de constructor is hetzelfde als de klassenaam.
  • Constructors worden meestal gedeclareerd in het openbare gedeelte van de klasse, hoewel ze ook in het privégedeelte van de klasse kunnen worden gedeclareerd.
  • Constructors retourneren geen waarden; daarom hebben ze geen retourtype.
  • Een constructor wordt automatisch aangeroepen wanneer we het object van de klasse maken.
  • Constructeurs kunnen overbelast raken.
  • Een constructor kan niet virtueel worden verklaard.
  • Een constructor kan niet worden geërfd.
  • Naar de adressen van de Constructeur kan niet worden verwezen.
  • De constructor voert impliciete oproepen uit naar nieuw En verwijderen operators tijdens geheugentoewijzing.

Soorten constructeurs in C++

Constructors kunnen worden geclassificeerd op basis van de situaties waarin ze worden gebruikt. Er zijn 4 soorten constructors in C++:

  1. Standaardconstructeur
  2. Geparametriseerde constructor
  3. Kopieer constructeur
  4. Constructeur verplaatsen

Laten we de typen constructors in C++ begrijpen door een voorbeeld uit de praktijk te nemen. Stel dat u naar een winkel gaat om een ​​stift te kopen. Wanneer u een marker wilt kopen, wat zijn dan de mogelijkheden? De eerste keer dat je naar een winkel gaat en zegt: geef me een marker. Dus als je zegt: geef me een marker, betekent dit dat je niet hebt ingesteld welke merknaam en welke kleur, je hebt niets vermeld, je zegt alleen dat je een marker wilt. Dus toen we zeiden: ik wil gewoon een marker, ongeacht de vaak verkochte marker die er op de markt of in zijn winkel is, zal hij die gewoon overhandigen. En dit is wat een standaardconstructor is!

De tweede methode is dat je naar een winkel gaat en zegt dat ik een marker in de kleur rood en het XYZ-merk wil. Dus je vermeldt dit en hij zal je die marker geven. Dus in dit geval hebt u de parameters opgegeven. En dit is wat een geparametriseerde constructor is!

Bij de derde keer ga je naar een winkel en zeg je: ik wil zo'n marker (een fysieke marker op je hand). De winkelier zal die markering dus zien. Oké, en hij zal je een nieuwe marker geven. Kopieer dus die markering. En dat is wat een copyconstructor is!

Stel nu dat je geen nieuwe marker koopt, maar in plaats daarvan eigenaar wordt van de marker van je vriend. Het betekent dat je eigenaar wordt van reeds aanwezige hulpbronnen, in plaats van nieuwe te verwerven. Dat is wat een moveconstructor is!

1. Standaardconstructor in C++

A standaardconstructeur is een constructor die geen enkel argument accepteert. Het heeft geen parameters. Het wordt ook wel een nul-argumentconstructor genoemd.

Syntaxis van standaardconstructor 

className() {     // body_of_constructor  }>

Voorbeelden van standaardconstructor

De onderstaande voorbeelden laten zien hoe u de standaardconstructors in C++ kunt gebruiken.

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

>

>

Uitvoer 

a: 10 b: 20>

Opmerking: Zelfs als we geen enkele constructor expliciet definiëren, zal de compiler automatisch impliciet een standaardconstructor leveren.

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

>

>

Uitvoer 

(no output)>

Zoals we kunnen zien, kunnen we het object van de klasstudent maken zonder enig argument door te geven, zelfs als we er geen expliciete standaardconstructor voor hebben gedefinieerd.

2. Geparametriseerde constructor in C++

Geparametriseerde constructors maken het mogelijk argumenten door te geven aan constructors. Normaal gesproken helpen deze argumenten bij het initialiseren van een object wanneer het wordt gemaakt. Om een ​​geparametriseerde constructor te maken, voegt u er eenvoudigweg parameters aan toe, zoals u dat aan elke andere functie zou doen. Wanneer u de hoofdtekst van de constructor definieert, gebruikt u de parameters om het object te initialiseren.

Syntaxis van geparametriseerde constructor 

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

Voorbeelden van geparametriseerde constructor

De onderstaande voorbeelden laten zien hoe u de geparametriseerde constructors in C++ kunt gebruiken.

Voorbeeld 1: Geparametriseerde constructor binnen de klasse definiëren.

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

>

>

Uitvoer 

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

Voorbeeld 2: Geparametriseerde constructor buiten de klasse definiëren.

C++


mysql lijst gebruikers



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

>

>

Uitvoer 

1001 Ram 10000>

Wanneer een object wordt gedeclareerd in een geparametriseerde constructor, moeten de initiële waarden als argumenten worden doorgegeven aan de constructorfunctie. De normale manier van objectdeclaratie werkt mogelijk niet. De geparametriseerde constructors kunnen expliciet of impliciet worden aangeroepen:

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

Wanneer de geparametriseerde constructor is gedefinieerd en er geen standaardconstructor expliciet is gedefinieerd, zal de compiler niet impliciet de standaardconstructor maken en dus een eenvoudig object maken als:

Student s;>

zal een fout knipperen.

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

>

>

doe terwijl java

Uitvoer 

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 ^~>

Belangrijke notitie: Telkens wanneer we een of meer niet-standaardconstructors( met parameters ) voor een klasse definiëren, moet er ook expliciet een standaardconstructor(zonder parameters) worden gedefinieerd, aangezien de compiler in dit geval geen standaardconstructor zal leveren. Het is echter niet noodzakelijk, maar het wordt als de beste praktijk beschouwd om altijd een standaardconstructor te definiëren.

Gebruik van geparametriseerde constructor

  • Het wordt gebruikt om de verschillende gegevenselementen van verschillende objecten met verschillende waarden te initialiseren wanneer ze worden gemaakt.
  • Het wordt gebruikt om constructeurs te overbelasten.

Standaardargumenten met C++ geparametriseerde constructor

Net als normale functies kunnen we ook standaardwaarden definiëren voor de argumenten van geparametriseerde constructors. Alle regels van de standaardargumenten zal op deze parameters worden toegepast.

Voorbeeld 3: Geparametriseerde constructor definiëren met standaardwaarden

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

>

>

Uitvoer 

First Object Data: 0 Second Object Data: 25>

Zoals we kunnen zien, is het, wanneer de standaardwaarden worden toegewezen aan elk argument van de geparametriseerde constructor, legaal om het object te maken zonder parameters door te geven, net als standaardconstructors. Dit type constructor werkt dus zowel als standaard- als als geparametriseerde constructor.

3. Kopieer Constructor in C++

Een kopieerconstructor is een lidfunctie die een object initialiseert met behulp van een ander object van dezelfde klasse.

Syntaxis van Kopieer constructeur

Kopieer constructor neemt een verwijzing naar een object van dezelfde klasse als argument.

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

Net als de standaardconstructor biedt de C++-compiler ook een impliciete kopieconstructor als de expliciete kopieconstructordefinitie niet aanwezig is. Hier moet worden opgemerkt dat, in tegenstelling tot de standaardconstructor, waarbij de aanwezigheid van welk type expliciete constructor dan ook resulteert in het verwijderen van de impliciete standaardconstructor, de impliciete kopieconstructor altijd door de compiler zal worden gemaakt als er geen expliciete kopieconstructor is. of er is een expliciete verplaatsingsconstructor aanwezig.

Voorbeelden van Copy Constructor

De onderstaande voorbeelden laten zien hoe u de kopieerconstructors in C++ kunt gebruiken.

Voorbeeld 1: Illustratie van Implicit Copy Constructor

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

>

>

Uitvoer 

ID=10 ID=10>

Voorbeeld 2: Definitie van een expliciete kopieconstructor

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

>

>

Uitvoer 

ID=10 ID=10>

Voorbeeld 3: Definitie van een expliciete kopieconstructor met een geparametriseerde constructor

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

Java-programmeerpatronen 
>

>

Uitvoer 

1001 Manjeet 10000 1001 Manjeet 10000>

Gebruik van Copy Constructor

  • Construeert een nieuw object door waarden van een bestaand object te kopiëren.
  • Kan worden gebruikt om diepe kopieën uit te voeren.
  • Wijzig indien nodig specifieke kenmerken tijdens het kopieerproces.

4. Verplaats Constructor in C++

De move-constructor is een recente toevoeging aan de familie van constructors in C++. Het is als een kopieerconstructor die het object construeert uit de reeds bestaande objecten. Maar in plaats van het object naar het nieuwe geheugen te kopiëren, maakt het gebruik van verplaatsingssemantiek om het eigendom van het reeds gemaakte object over te dragen aan het nieuwe object zonder extra te creëren kopieën.

Het kan worden gezien als het stelen van hulpbronnen van andere objecten.

Syntaxis van Move Constructor in C++

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

De verplaats constructeur neemt de rwaarde-referentie van het object van dezelfde klasse en draagt ​​het eigendom van dit object over aan het nieuw gemaakte object.

Net als een kopie-constructor zal de compiler een move-constructor maken voor elke klasse die geen expliciete move-constructor heeft.

Voorbeelden van Move Constructor

De onderstaande voorbeelden laten zien hoe u de move-constructors in C++ gebruikt.

Voorbeeld 1: Verplaatsconstructor definiëren

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

>

>

Uitvoer 

Move Constructor Called newBox.data: 42>

Gebruik van Move Constructor

  • In plaats van kopieën te maken, kunnen move-constructors op efficiënte wijze het eigendom van deze bronnen overdragen.
  • Dit voorkomt onnodig geheugenkopiëren en vermindert de overhead.
  • U kunt uw eigen verplaatsingsconstructor definiëren om specifieke resourceoverdrachten af ​​te handelen.

Destructors in C++

Een destructor heeft ook een speciale ledenfunctie als constructor. Destructor vernietigt de klasseobjecten die door de constructor zijn gemaakt. Destructor heeft dezelfde naam als hun klassenaam, voorafgegaan door een tilde (~) symbool. Het is niet mogelijk om meer dan één destructor te definiëren. De destructor is slechts één manier om het door de constructor gemaakte object te vernietigen. Daarom kan de destructor niet overbelast worden. Destructor vereist geen enkel argument en retourneert geen enkele waarde. Het wordt automatisch aangeroepen wanneer het object buiten bereik raakt. Destructors maken geheugenruimte vrij die wordt ingenomen door de objecten die door de constructor zijn gemaakt. In torpedojager worden objecten vernietigd in het omgekeerde van het creëren van objecten.

Syntaxis van Destructors in C++

Net als constructors kunnen destructors ook binnen of buiten de klasse worden gedefinieerd.

De syntaxis voor het definiëren van de destructor binnen de klasse 

~ (){}>

De syntaxis voor het definiëren van de destructor buiten de klasse 

: : ~(){}>

Voorbeelden van destructors in C++

De onderstaande voorbeelden laten zien hoe u de destructors in C++ gebruikt.

Voorbeeld 1: Een eenvoudige destructor definiëren

C++




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

>

>

sql-server draaipunt
Uitvoer 

 Constructor executed Destructor executed>

Voorbeeld 2: Tellen van het aantal keren dat een object is gemaakt en vernietigd

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

>

>

Uitvoer 

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>

Kenmerken van Destructors in C++

Hieronder volgen enkele hoofdkenmerken van destructors in C++:

  • Destructor wordt automatisch aangeroepen door de compiler wanneer de corresponderende constructor buiten het bereik valt en geheugenruimte vrijgeeft die niet langer nodig is voor het programma.
  • Destructor vereist geen enkel argument en retourneert geen waarde en kan daarom niet overbelast worden.
  • Destructor kan niet als statisch en const worden gedeclareerd;
  • Destructor moet worden aangegeven in het openbare gedeelte van het programma.
  • Destructor wordt aangeroepen in de omgekeerde volgorde van het aanroepen van de constructor.

Veelgestelde vragen over C++-constructeurs

Wat zijn de functies die standaard door de compiler worden gegenereerd, als we ze niet expliciet aanbieden?

De functies die standaard door de compiler worden gegenereerd als we ze niet expliciet aanbieden, zijn:

  1. Standaardconstructeur
  2. Kopieer constructeur
  3. Verplaats constructeurs
  4. Opdracht Operator
  5. Torpedojager

Kunnen we de constructeurs privé maken?

Ja, in C++ kunnen constructors privé worden gemaakt. Dit betekent dat geen enkele externe code rechtstreeks een object van die klasse kan maken.

Hoe verschillen constructors van een normale lidfunctie?

Een constructor verschilt op de volgende manieren van normale functies:

  • Constructor heeft dezelfde naam als de klasse zelf
  • Standaardconstructors hebben echter geen invoerargumenten. Kopieer- en geparametriseerde constructors hebben invoerargumenten
  • Constructors hebben geen retourtype
  • Er wordt automatisch een constructor aangeroepen wanneer een object wordt gemaakt.
  • Het moet in het openbare gedeelte van de klas worden geplaatst.
  • Als we geen constructor specificeren, genereert de C++-compiler een standaardconstructor voor het object (verwacht geen parameters en heeft een lege body).

Kunnen we meer dan één constructeur in een klas hebben?

Ja, we kunnen meer dan één constructor in een klasse hebben. Het heet Overbelasting van de constructeur .

Gerelateerde artikelen:

  • Destructors in C++
  • Quiz over constructeurs in C++
  • Uitvoer van C++-programma's | Set 26 (constructeurs)
  • Uitvoer van C++-programma's | Set 27 (Constructors en Destructors)