Konstruktori C++:ssa on erityinen menetelmä, jota kutsutaan automaattisesti objektin luonnin yhteydessä. Sitä käytetään yleisesti uusien objektien tietojäsenten alustamiseen. C++:n konstruktorilla on sama nimi kuin luokalla tai rakenteella. Se muodostaa arvot eli tarjoaa dataa objektille, minkä vuoksi se tunnetaan rakentajana.
- Konstruktori on luokan jäsenfunktio, jonka nimi on sama kuin luokan nimi.
- Konstruktori on erityinen jäsenfunktio, jota käytetään alustamaan luokan objektin datajäsenet automaattisesti, kun saman luokan objekti luodaan.
- Konstruktoria kutsutaan objektin luomisen yhteydessä. Se rakentaa arvot eli tarjoaa dataa objektille, minkä vuoksi se tunnetaan rakentajana.
- Rakentajat eivät palauta arvoa, joten niillä ei ole palautustyyppiä.
- Konstruktori kutsutaan automaattisesti, kun luomme luokan objektin.
- Rakentajat voivat olla ylikuormitettuja.
- Konstruktoria ei voida julistaa virtuaaliseksi.
Konstruktorien syntaksi C++:ssa
Rakentajan prototyyppi näyttää tältä:
(list-of-parameters);>
Konstruktori voidaan määrittää luokkailmoituksen sisällä tai luokkamäärityksen ulkopuolella
Syntaksi rakentajan määrittämiseksi luokassa
(list-of-parameters) { // constructor definition }> Syntaksi rakentajan määrittämiseen luokan ulkopuolella
: :(list-of-parameters) { // constructor definition }> Esimerkkejä C++:n konstruktoreista
Alla olevat esimerkit osoittavat, kuinka luokan konstruktorit määritellään C++:ssa:
Esimerkki 1: Luokan rakentajan määrittäminen
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>> nimi;> >cout <<>'Enter the Fee:'>;> >cin>> maksu;> >}> >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;> }> |
>
>
Lähtö
Enter the RollNo:121 Enter the Name:Geeks Enter the Fee:5000 121 Geeks 5000>
Esimerkki 2: Luokan ulkopuolisen konstruktorin määrittäminen
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>> nimi;> >cout <<>'Enter the Fee:'>;> >cin>> maksu;> }> void> student::display()> {> >cout << endl << rno <<>' '> << name <<>' '> << fee;> }> // driver code> int> main()> {> >student s;> >s.display();> >return> 0;> }> |
>
>
Lähtö
Enter the RollNo:11 Enter the Name:Aman Enter the Fee:10111 11 Aman 10111>
Huomautus: Konstruktori voidaan määrittää luokan ulkopuolella nimellä linjassa jotta se vastaa luokan määritelmää. Mutta huomioi se linjassa ei ole ohje kääntäjälle, se on vain pyyntö, jonka kääntäjä voi toteuttaa tai olla toteuttamatta olosuhteista riippuen.
C++:n konstruktorien ominaisuudet
Seuraavassa on joitain C++:n konstruktorien pääominaisuuksia:
- Rakentajan nimi on sama kuin sen luokan nimi.
- Rakentajat ilmoitetaan enimmäkseen luokan julkisessa osiossa, vaikka ne voidaan ilmoittaa luokan yksityisessä osiossa.
- Rakentajat eivät palauta arvoja; siksi niillä ei ole palautustyyppiä.
- Konstruktori kutsutaan automaattisesti, kun luomme luokan objektin.
- Rakentajat voivat olla ylikuormitettuja.
- Konstruktoria ei voida julistaa virtuaaliseksi.
- Rakentajaa ei voi periä.
- Rakentajan osoitteisiin ei voi viitata.
- Konstruktori soittaa implisiittisiä kutsuja Uusi ja poistaa operaattorit muistin varauksen aikana.
Konstruktorityypit C++:ssa
Rakentajat voidaan luokitella sen mukaan, missä tilanteissa niitä käytetään. C++:ssa on neljää tyyppiä konstruktoreita:
- Oletuskonstruktori
- Parametrisoitu konstruktori
- Kopioi rakentaja
- Siirrä rakentaja
Ymmärrämme C++:n konstruktorityyppejä ottamalla todellisen esimerkin. Oletetaan, että menit kauppaan ostamaan merkkiä. Mitä vaihtoehtoja on, kun haluat ostaa merkin? Ensimmäinen, jonka menet kauppaan ja sanot, että anna minulle tussi. Joten pelkkä sanominen anna minulle merkki tarkoittaa, että et ole määrittänyt minkä tuotemerkin ja minkä värin, et maininnut mitään, vain sanot, että haluat merkin. Joten kun sanoimme vain, että haluan tussin riippumatta siitä, mitä usein myydään markkinoilla tai hänen myymälässään, hän yksinkertaisesti luovuttaa sen. Ja tämä on oletuskonstruktori!
Toinen tapa on mennä kauppaan ja sanoa, että haluan punaisen tussin ja XYZ-merkin. Joten sinä mainitset tämän ja hän antaa sinulle tuon merkin. Joten tässä tapauksessa olet antanut parametrit. Ja tätä parametroitu konstruktori on!
Sitten kolmannessa menet kauppaan ja sanot, että haluan tällaisen tussin (fyysisen merkin käteesi). Joten kauppias näkee tuon merkin. Okei, ja hän antaa sinulle uuden merkin. Joten kopio tuosta merkistä. Ja sitähän kopiokonstruktori on!
Oletetaan nyt, että et osta uutta merkkiä vaan otat ystäväsi merkin omistukseen. Se tarkoittaa jo olemassa olevien resurssien omistamista uusien hankkimisen sijaan. Sellaista liikkeen rakentaja on!
1. C++:n oletuskonstruktori
A oletuskonstruktori on rakentaja, joka ei ota vastaan mitään argumentteja. Sillä ei ole parametreja. Sitä kutsutaan myös nolla-argumenttikonstruktoriksi.
Oletuskonstruktorin syntaksi
className() { // body_of_constructor }> Esimerkkejä oletuskonstruktorista
Alla olevat esimerkit osoittavat, kuinka oletuskonstruktoreita käytetään C++:ssa.
Esimerkki 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;> }> |
>
>Lähtö
a: 10 b: 20>
Huomautus: Vaikka emme määrittäisikään mitään konstruktoria eksplisiittisesti, kääntäjä tarjoaa automaattisesti oletuskonstruktorin implisiittisesti.
Esimerkki 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;> }> |
>
>
Lähtö
(no output)>
Kuten näemme, luokan opiskelijan objekti voidaan luoda ilman argumenttia, vaikka emme olisi määrittäneet sille mitään eksplisiittistä oletuskonstruktoria.
2. Parametrisoitu konstruktori C++:ssa
Parametriset konstruktorit mahdollistavat argumenttien välittämisen rakentajille. Yleensä nämä argumentit auttavat alustamaan objektia, kun se luodaan. Voit luoda parametroidun konstruktorin lisäämällä siihen parametreja samalla tavalla kuin mihin tahansa muuhun funktioon. Kun määrität rakentajan rungon, käytä parametreja objektin alustamiseen.
Parametrisoidun konstruktorin syntaksi
className (parameters...) { // body }> Esimerkkejä parametroidusta konstruktorista
Alla olevat esimerkit osoittavat, kuinka parametroituja konstruktoreita käytetään C++:ssa.
Esimerkki 1: Parametrisoidun konstruktorin määrittäminen luokan sisällä.
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;> }> |
>
>Lähtö
p1.x = 10, p1.y = 15>
Esimerkki 2: Parametrisoidun konstruktorin määrittäminen luokan ulkopuolella.
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;> }> |
>
>Lähtö
1001 Ram 10000>
Kun objekti on määritelty parametroidussa konstruktorissa, alkuarvot on välitettävä argumenteina konstruktorifunktiolle. Tavallinen objektin ilmoitustapa ei välttämättä toimi. Parametrisoituja konstruktoreita voidaan kutsua eksplisiittisesti tai implisiittisesti:
Example e = Example(0, 50); // Explicit call Example e(0, 50); // Implicit call>
Kun parametrisoitu konstruktori on määritetty eikä oletuskonstruktoria ole määritelty erikseen, kääntäjä ei luo implisiittisesti oletuskonstruktoria ja siten yksinkertaista objektia seuraavasti:
Student s;>
vilkkuu virheilmoitus.
Esimerkki 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;> }> |
>
>
Lähtö
poikkeus heittää java
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 ^~> Tärkeä muistiinpano: Aina kun määritämme luokalle yhden tai useamman ei-oletuskonstruktorin (parametreineen), oletuskonstruktori (ilman parametreja) tulisi myös määritellä erikseen, koska kääntäjä ei tarjoa oletuskonstruktoria tässä tapauksessa. Se ei kuitenkaan ole välttämätöntä, mutta sitä pidetään parhaana käytäntönä määrittää aina oletuskonstruktori.
Parametrisoidun konstruktorin käyttötarkoitukset
- Sitä käytetään alustamaan eri objektien tietoelementit eri arvoilla, kun niitä luodaan.
- Sitä käytetään rakentajien ylikuormitukseen.
Oletusargumentit C++-parametrisoidulla konstruktorilla
Kuten normaalit funktiot, voimme myös määrittää oletusarvot parametroitujen konstruktorien argumenteille. Kaikki säännöt oletusargumentit sovelletaan näihin parametreihin.
Esimerkki 3: Parametrisoidun konstruktorin määrittäminen oletusarvoilla
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;> }> |
>
>Lähtö
First Object Data: 0 Second Object Data: 25>
Kuten näemme, kun oletusarvot on määritetty parametroidun konstruktorin jokaiselle argumentille, on laillista luoda objekti ilman parametrien välittämistä, aivan kuten oletuskonstruktorit. Joten tämäntyyppinen konstruktori toimii sekä oletus- että parametroituna rakentajana.
3. Kopioi Constructor C++:ssa
Kopiokonstruktori on jäsenfunktio, joka alustaa objektin käyttämällä toista saman luokan objektia.
Kohteen syntaksi Kopioi rakentaja
Kopioi rakentaja ottaa viittauksen saman luokan objektiin argumenttina.
ClassName (ClassName &obj) { // body_containing_logic }> Aivan kuten oletuskonstruktori, C++-kääntäjä tarjoaa myös implisiittisen kopiokonstruktorin, jos eksplisiittistä kopiokonstruktorin määritelmää ei ole. Tässä on huomioitava, että toisin kuin oletuskonstruktorissa, jossa minkä tahansa tyyppisen eksplisiittisen konstruktorin läsnäolo johtaa implisiittisen oletuskonstruktorin poistamiseen, kääntäjä luo aina implisiittisen kopiokonstruktorin, jos eksplisiittistä kopiokonstruktoria ei ole olemassa. tai eksplisiittinen siirtokonstruktori on läsnä.
Esimerkkejä Copy Constructorista
Alla olevat esimerkit osoittavat kuinka käyttää kopiointikonstruktoreja C++:ssa.
Esimerkki 1: Kuva implicit Copy Constructorista
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;> }> |
>
>Lähtö
ID=10 ID=10>
Esimerkki 2: Explicit Copy Constructorin määrittely
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;> }> |
>
>Lähtö
ID=10 ID=10>
Esimerkki 3: Explicit Copy Constructorin määrittäminen parametroidulla konstruktorilla
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;> }> |
>
>Lähtö
1001 Manjeet 10000 1001 Manjeet 10000>
Copy Constructorin käyttötarkoitukset
- Rakentaa uuden objektin kopioimalla arvot olemassa olevasta objektista.
- Voidaan käyttää syväkopiointiin.
- Muokkaa tiettyjä määritteitä kopioinnin aikana tarvittaessa.
4. Siirrä Constructor C++:ssa
Move-konstruktori on tuore lisäys C++:n konstruktoriperheeseen. Se on kuin kopiokonstruktori, joka rakentaa objektin jo olemassa olevista objekteista., mutta sen sijaan, että se kopioiisi objektin uuteen muistiin, se käyttää siirtosemantiikkaa siirtääkseen jo luodun objektin omistajuuden uudelle objektille luomatta ylimääräistä kopioita.
Sen voidaan nähdä resurssien varastamisena muista objekteista.
Move Constructorin syntaksi C++:ssa
className (className&& obj) { // body of the constructor }> The siirrä rakentaja ottaa rarvoviittaus saman luokan objektin ja siirtää tämän objektin omistusoikeuden äskettäin luodulle objektille.
Kuten kopiokonstruktori, kääntäjä luo siirtokonstruktorin jokaiselle luokalle, jolla ei ole erityistä siirtokonstruktoria.
Esimerkkejä Move Constructorista
Alla olevat esimerkit osoittavat, kuinka siirtokonstruktoreita käytetään C++:ssa.
Esimerkki 1: Move Constructorin määrittäminen
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;> }> |
>
>Lähtö
Move Constructor Called newBox.data: 42>
Move Constructorin käyttötarkoitukset
- Kopioinnin sijaan siirron rakentajat siirtävät tehokkaasti näiden resurssien omistajuuden.
- Tämä estää tarpeettoman muistin kopioimisen ja vähentää ylimääräisiä kustannuksia.
- Voit määrittää oman siirtokonstruktorin käsittelemään tiettyjä resurssisiirtoja.
Destruktorit C++:ssa
Destruktori on myös erityinen jäsentoiminto konstruktorina. Destructor tuhoaa rakentajan luomat luokkaobjektit. Destructorilla on sama nimi kuin niiden luokan nimellä, jota edeltää tilde (~) -symboli. Ei ole mahdollista määritellä useampaa kuin yhtä tuhoajaa. Tuhoaja on vain yksi tapa tuhota rakentajan luoma esine. Siksi tuhoajaa ei voida ylikuormittaa. Destructor ei vaadi argumentteja eikä palauta arvoa. Sitä kutsutaan automaattisesti, kun objekti menee soveltamisalan ulkopuolelle. Destruktorit vapauttavat rakentajan luomien objektien käyttämän muistitilan. Sisään hävittäjä , objektit tuhoutuvat objektin luomisen käänteisessä järjestyksessä.
Destruktoreiden syntaksi C++:ssa
Kuten konstruktorit, myös destruktorit voidaan määritellä joko luokan sisällä tai ulkopuolella.
Syntaksi destruktorin määrittämiseksi luokassa
~ (){}> Syntaksi luokan ulkopuolisen destruktorin määrittämiseen
: : ~(){}> Esimerkkejä C++:n destructoreista
Alla olevat esimerkit osoittavat, kuinka destruktoreita käytetään C++:ssa.
Esimerkki 1: Yksinkertaisen tuhoajan määrittäminen
C++
#include> using> namespace> std;> class> Test {> public>:> >Test() { cout <<>'
Constructor executed'>; }> >~Test() { cout <<>'
Destructor executed'>; }> };> main()> {> >Test t;> >return> 0;> }> |
>
>Lähtö
Constructor executed Destructor executed>
Esimerkki 2: Objektin luomis- ja tuhoutumiskertojen laskeminen
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;> }> |
>
>
Lähtö
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>
Destruktoreiden ominaisuudet C++:ssa
Seuraavassa on joitain C++:n destruktoreiden pääominaisuuksia:
- Kääntäjä kutsuu Destructorin automaattisesti, kun sitä vastaava rakentaja poistuu toiminta-alueelta ja vapauttaa muistitilan, jota ohjelma ei enää tarvitse.
- Destructor ei vaadi argumentteja eikä palauta arvoa, joten sitä ei voi ylikuormittaa.
- Destruktoria ei voida ilmoittaa staattiseksi ja const;
- Tuhoaja tulee ilmoittaa ohjelman julkisessa osiossa.
- Destructoria kutsutaan käänteisessä järjestyksessä kuin sen rakentaja kutsuu.
Usein kysyttyjä kysymyksiä C++-konstruktoreista
Mitkä ovat kääntäjän oletusarvoisesti luomat toiminnot, jos emme tarjoa niitä nimenomaisesti?
Kääntäjän oletusarvoisesti luomat toiminnot, jos emme anna niitä erikseen, ovat:
- Oletuskonstruktori
- Kopioi rakentaja
- Siirrä rakentajia
- Tehtäväoperaattori
- Hävittäjä
Voimmeko tehdä rakentajista yksityisiä?
Kyllä, C++:ssa konstruktorit voidaan tehdä yksityisiksi. Tämä tarkoittaa, että mikään ulkoinen koodi ei voi suoraan luoda kyseisen luokan objektia.
Miten rakentajat eroavat tavallisesta jäsenfunktiosta?
Konstruktori eroaa normaaleista funktioista seuraavilla tavoilla:
- Rakentajalla on sama nimi kuin itse luokalla
- Oletuskonstruktoreissa ei kuitenkaan ole syöttöargumentteja, mutta kopiointi- ja parametroiduilla konstruktorilla on syöttöargumentit
- Rakentajilla ei ole palautustyyppiä
- Konstruktori kutsutaan automaattisesti, kun objekti luodaan.
- Se on sijoitettava luokan julkiseen osioon.
- Jos emme määritä rakentajaa, C++-kääntäjä luo objektille oletuskonstruktorin (ei odota parametreja ja siinä on tyhjä runko).
Voiko luokassa olla useampi kuin yksi rakentaja?
Kyllä, meillä voi olla useampi kuin yksi rakentaja luokassa. Sitä kutsutaan Rakentajan ylikuormitus .
Aiheeseen liittyvät artikkelit:
- Destruktorit C++:ssa
- Tietovisa rakentajista C++:ssa
- C++-ohjelmien tulos | Sarja 26 (rakentajat)
- C++-ohjelmien tulos | Sarja 27 (rakentajat ja tuhoajat)