Gayunpaman, maaaring umiral ang isang virtual na destructor. Dito, ipapakita namin kung ano ang mangyayari kapag lumikha kami ng isang virtual constructor sa C++ pati na rin ang mga paggana ng virtual destructor sa halip na ang virtual na constructor.
Halimbawa 1:
Gawin natin ang virtual constructor at simulan ang ating code sa pamamagitan ng paglalagay ng 'iostream' header file. Ang header file na ito ay para sa mga function na idineklara dito tulad ng 'cin' at 'cout'. Pagkatapos nito, idinaragdag namin ang 'std' namespace, kaya hindi namin maidagdag ang 'std' na ito sa bawat function sa aming code. Pagkatapos nito, lumikha kami ng isang klase na siyang batayang klase ng aming code na may pangalang 'my_base' at pagkatapos ay idagdag ang 'pampubliko' upang lumikha ng virtual na tagabuo.
Ang virtual constructor ay nilikha dito sa pamamagitan ng paglalagay ng 'virtual' na keyword. Sa loob ng virtual constructor na ito, naglalagay kami ng 'cout' na pahayag. Sa ibaba nito, gumawa kami ng function na pinangalanang 'show' kung saan muli naming ginagamit ang 'cout'. Pagkatapos nito, lumikha kami ng isang nagmula na klase ng base class na ito na may pangalang 'my_derived' at pagkatapos ay itatag ang 'my_derived()' constructor sa field na 'public'. Naglalagay kami ng 'cout' na pahayag sa constructor na ito na 'my_derived()'. Sa ibaba nito, bumuo kami ng function na tinatawag na 'show' kung saan muli naming ginagamit ang 'cout'.
Ngayon, pagkatapos gamitin ang 'main()', lumikha kami ng pointer ng base class na may pangalang 'my_ptr' at lumikha din ng object ng nagmula na klase na 'Obj_d'. Pagkatapos nito, itinalaga namin ang address ng 'Obj_d' sa 'my_ptr'. Pagkatapos, tinatawag namin ang function na 'show()' sa pamamagitan ng 'my_ptr'.
Code 1:
#include
gamit namespace std ;
klase my_base
{
pampubliko :
virtual my_base ( )
{
cout << 'Narito ang aking base class' << endl ;
}
walang bisa palabas ( )
{
cout << 'ang ipakita ang function ng base class' << endl ;
}
} ;
klase my_derived : pampubliko my_base
{
pampubliko :
my_derived ( )
{
cout << 'Narito ang aking hinangong klase' << endl ;
}
walang bisa palabas ( )
{
cout << 'ang ipakita ang function ng nagmula na klase' < palabas ( ) ;
}
Output:
Dito, ito ay nagpapakita ng isang mensahe ng error na nagsasabing ang constructor ay hindi maaaring ideklarang virtual sa C++ programming. Kaya, makikita natin na hindi tayo pinapayagan ng C++ na bumuo ng virtual constructor ngunit maaari tayong lumikha ng virtual na destructor.
Halimbawa 2:
Lutasin natin ang nakaraang problema at likhain ang virtual destructor sa code na ito. Pagkatapos ideklara ang klase ng 'new_base', inilalagay namin ang 'pampubliko' na tagabuo kung saan nilikha namin ang virtual na destructor sa pamamagitan ng pagdaragdag ng 'virtual ~' sa 'new_base'. Naglalagay kami ng 'cout' na pahayag sa virtual na destructor na ito. Sa ibaba nito, bumuo kami ng function na tinatawag na 'show' na gumagamit ng 'cout'. Susunod, gumawa kami ng derived class na 'new_derived' ng 'new_base' base class na ito at bumuo ng 'new_derived()'destructor sa 'public' field. Ang 'new_derived()' destructor na ito ay mayroon na ngayong 'cout' na pahayag na idinagdag dito.
Sa ibaba nito, gumawa kami ng function na tinatawag na 'show' na gumagamit muli ng 'cout' statement. Pagkatapos tawagan ang function na 'main()', gumagawa na kami ngayon ng object ng 'obj_d' derived class pati na rin ang pointer ng base class na pinangalanang 'ptr1'. Kasunod nito, ibibigay namin ang 'obj_d' na address sa 'ptr1'. Susunod, ang 'show()' na paraan ay ginagamit gamit ang 'ptr1'.
Code 2:
#includegamit namespace std ;
klase bagong_base
{
pampubliko :
virtual ~new_base ( )
{
cout << 'Narito na ang base class destructor' << endl ;
}
walang bisa palabas ( )
{
cout << 'Ang show function ng base class' << endl ;
}
} ;
klase new_derived : pampubliko bagong_base
{
pampubliko :
~new_derived ( )
{
cout << 'Narito ang derived class destructor' << endl ;
}
walang bisa palabas ( )
{
cout << 'Ang show function ng base class' < palabas ( ) ;
}
Output:
Gumagamit ang program na ito ng pointer object ng 'new_base' na tumuturo sa 'obj_d' derived class. Kaya, tinawag muna nito ang 'show()' na paraan ng klase na 'new_base'. Pagkatapos, tinatawag nito ang '~new_derived()' na paraan ng 'new_derived' na klase at ipinapakita ang '~new_base' ng base class.
Halimbawa 3:
Narito ang isa pang code upang makabuo ng 'virtual' na tagabuo. Pagkatapos isama ang 'iostream' at ang 'std' namespace, bumubuo kami ng klase na 'B'. Sa ibaba nito, nilikha namin ang 'pampubliko' na tagabuo na 'B()' at pagkatapos ay bubuo ng 'cout'. Ang mga function ng constructor at destructor ay tinukoy sa pamamagitan ng paggamit ng 'pampublikong' access specifier kung saan maaaring tumawag ang anumang bagay sa klase.
Ngayon, lumikha din kami ng '~B()' na destructor ng base class na ito kung saan muli naming ginagamit ang 'cout'. Pagkatapos, gagawa kami ng 'D' na klase na nagmula sa klase ng 'B' na batayang klase at inilalagay ang 'pampubliko' dito. Sa loob ng 'pampubliko' na ito, nilikha namin ang constructor pati na rin ang destructor ng nagmula na klase na may mga pangalang 'D()' at '~D', ayon sa pagkakabanggit. Parehong naglalaman ng 'cout' sa loob ng mga ito. Ngayon, mayroon kaming 'pangunahing ()' function. Pagkatapos tawagan ang function na ito, bumubuo kami ng pointer object ng base class.
Pagkatapos, ginagamit namin ang keyword na 'tanggalin' at inilalagay ang 'base_ptr' dito. Sa kasong ito, ang espasyo ng destructor ay tatanggalin sa pamamagitan ng pagtawag sa pointer object ng base class.
Code 3:
#includegamit namespace std ;
klase B
{
pampubliko :
B ( )
{
cout << 'Konstruktor ng Base class' << endl ;
}
~B ( )
{
cout << 'Destructor ng Base class' << endl ;
}
} ;
klase D : pampubliko B
{
pampubliko :
D ( )
{
cout << 'Constructor ng Derived class' << endl ;
}
~D ( )
{
cout << 'Destructor ng Derived class' << endl ;
}
} ;
int pangunahing ( )
{
B * base_ptr = bago D ;
tanggalin base_ptr ;
}
Output:
Ang resulta ay nagpapakita na ito ay gumagamit ng pointer object na tumuturo sa 'B' na klase sa pangunahing function. Kaya, tinawag muna nito ang 'constructor()' ng klase ng 'B'. Pagkatapos, tinatawag nito ang 'constructor()' ng 'D' class. Ang pointer object na hawak ng mga destructors ng 'B' at 'D' na mga klase ay tatanggalin. Nang walang pag-invoke sa destructor ng 'D' na klase sa loob ng programa, ang 'B' class pointer ay inaalis lang ang destructor ng 'B' na klase. Bilang resulta, nasira ang memorya ng programa.
Konklusyon
Tinalakay namin ang konsepto ng 'Virtual construction' sa C++ programming. Ginalugad namin na hindi namin magagawa ang virtual na tagabuo sa C++, ngunit maaari naming gawin ang virtual na destructor sa aming mga code. Dito, ipinakita namin kung ano ang nangyari noong lumikha kami ng virtual constructor sa C++ programming at ang mga gumagana ng virtual destructor sa aming mga code. Nalaman namin na ang constructor ay hindi maaaring maging virtual, ngunit maaari naming bumuo ng virtual na destructor sa aming klase. Nagpakita kami ng ilang halimbawa at ipinaliwanag nang lubusan ang mga code na ito sa gabay na ito.