Cu toate acestea, ar putea exista un destructor virtual. Aici, vom arăta ce se întâmplă atunci când creăm un constructor virtual în C++, precum și funcționarea destructorului virtual în locul constructorului virtual.
Exemplul 1:
Să creăm constructorul virtual și să începem codul prin plasarea fișierului antet „iostream”. Acest fișier antet este pentru funcțiile care sunt declarate în el precum „cin” și „cout”. După aceasta, adăugăm spațiul de nume „std”, așa că nu putem adăuga acest „std” cu fiecare funcție din codul nostru. După aceasta, creăm o clasă care este clasa de bază a codului nostru cu numele „my_base” și apoi adăugăm „public” pentru a crea constructorul virtual.
Constructorul virtual este creat aici prin plasarea cuvântului cheie „virtual”. În interiorul acestui constructor virtual, plasăm o declarație „cout”. Sub aceasta, creăm o funcție numită „show” în care folosim din nou „cout”. După aceasta, creăm o clasă derivată a acestei clase de bază cu numele „my_derived” și apoi stabilim constructorul „my_derived()” în câmpul „public”. Inserăm o instrucțiune „cout” în acest constructor „my_derived()”. Sub ea, construim o funcție numită „show” în care folosim din nou „cout”.
Acum, după invocarea „main()”, creăm un pointer al clasei de bază cu numele „my_ptr” și, de asemenea, creăm obiectul clasei derivate care este „Obj_d”. După aceasta, atribuim adresa „Obj_d” lui „my_ptr”. Apoi, numim funcția „show()” prin „my_ptr”.
Cod 1:
#include
folosind spatiu de nume std ;
clasă baza_mea
{
public :
virtual baza_mea ( )
{
cout << 'Iată clasa mea de bază' << endl ;
}
gol spectacol ( )
{
cout << „funcția de afișare a clasei de bază” << endl ;
}
} ;
clasă my_derivat : public baza_mea
{
public :
my_derivat ( )
{
cout << „Iată clasa mea derivată” << endl ;
}
gol spectacol ( )
{
cout << „funcția de afișare a clasei derivate” < spectacol ( ) ;
}
Ieșire:
Aici, arată un mesaj de eroare care spune că constructorul nu poate fi declarat virtual în programarea C++. Deci, putem vedea că C++ nu ne permite să generăm constructorul virtual, dar putem crea destructorul virtual.
Exemplul 2:
Să rezolvăm problema anterioară și să creăm destructorul virtual în acest cod. După declararea clasei „new_base”, plasăm constructorul „public” în care creăm destructorul virtual adăugând „virtual ~” cu „new_base”. Inserăm o declarație „cout” în acest destructor virtual. Sub ea, construim o funcție numită „show” care folosește „cout”. Apoi, facem o clasă derivată care este „new_derived” din această clasă de bază „new_base” și construim destructorul „new_derived()” în câmpul „public”. Acest destructor „new_derived()” are acum o declarație „cout” adăugată.
Sub ea, creăm o funcție numită „show” care folosește din nou declarația „cout”. După apelarea funcției „main()”, acum producem un obiect al clasei derivate „obj_d”, precum și un pointer al clasei de bază numit „ptr1”. După aceea, dăm adresa „obj_d” la „ptr1”. Apoi, metoda „show()” este invocată folosind „ptr1”.
Cod 2:
#includefolosind spatiu de nume std ;
clasă baza_noua
{
public :
virtual ~nouă_bază ( )
{
cout << „Destructorul clasei de bază este aici” << endl ;
}
gol spectacol ( )
{
cout << „Funcția de afișare a clasei de bază” << endl ;
}
} ;
clasă nou_derivat : public baza_noua
{
public :
~derivat_nou ( )
{
cout << „Destructorul de clasă derivată este aici” << endl ;
}
gol spectacol ( )
{
cout << „Funcția de afișare a clasei de bază” < spectacol ( ) ;
}
Ieșire:
Acest program folosește un obiect pointer al „new_base” care indică spre clasa derivată „obj_d”. Astfel, apelează mai întâi metoda „show()” a clasei „new_base”. Apoi, apelează metoda „~new_derived()” a clasei „new_derived” și afișează „~new_base” a clasei de bază.
Exemplul 3:
Iată un alt cod pentru a genera constructorul „virtual”. După includerea spațiului de nume „iostream” și „std”, generăm o clasă „B”. Sub acesta, creăm constructorul „public” care este „B()” și apoi generăm „cout”. Funcțiile constructor și destructor sunt definite prin utilizarea unui specificator de acces „public” în care poate apela orice obiect din clasă.
Acum, creăm și destructorul „~B()” al acestei clase de bază în care folosim din nou „cout”. Apoi, creăm clasa „D” care este clasa derivată a clasei de bază „B” și plasăm „publicul” aici. În interiorul acestui „public”, creăm atât constructorul cât și destructorul clasei derivate cu numele „D()” și respectiv „~D”. Ambele conțin „cout” în interiorul lor. Acum, avem funcția „main()”. După apelarea acestei funcții, generăm obiectul pointer al clasei de bază.
Apoi, folosim cuvântul cheie „șterge” și plasăm „base_ptr” aici. În acest caz, spațiul destructorului este șters prin apelarea obiectului pointer al clasei de bază.
Cod 3:
#includefolosind spatiu de nume std ;
clasă B
{
public :
B ( )
{
cout << „Constructorul clasei de bază” << endl ;
}
~B ( )
{
cout << „Destructorul clasei de bază” << endl ;
}
} ;
clasă D : public B
{
public :
D ( )
{
cout << „Constructorul clasei derivate” << endl ;
}
~D ( )
{
cout << „Destructorul clasei derivate” << endl ;
}
} ;
int principal ( )
{
B * baza_ptr = nou D ;
șterge baza_ptr ;
}
Ieșire:
Rezultatul arată că folosește un obiect pointer care indică clasa „B” în funcția principală. Astfel, apelează mai întâi „constructorul()” al clasei „B”. Apoi, apelează „constructorul()” din clasa „D”. Obiectul pointer care este deținut de destructorii claselor „B” și „D” este apoi șters. Fără a invoca destructorul clasei „D” în cadrul programului, indicatorul clasei „B” elimină doar destructorul clasei „B”. Ca urmare, memoria programului este coruptă.
Concluzie
Am discutat despre conceptul de „construcție virtuală” în programarea C++. Am explorat că nu putem crea constructorul virtual în C++, dar putem crea destructorul virtual în codurile noastre. Aici, am arătat ce s-a întâmplat când am creat constructorul virtual în programarea C++ și funcționarea destructorului virtual în codurile noastre. Am învățat că constructorul nu poate fi virtual, dar putem genera destructorul virtual în clasa noastră. Am demonstrat câteva exemple și am explicat aceste coduri în detaliu în acest ghid.