Virtual de programare de bază în clasa C și c

// program conține o eroare și nu va compila
#include
publice de bază de clasă:
int i;
>;
// d1 moștenește de bază.
clasa d1. publice de bază publică:
int j;






>;
// d2 moștenește de bază.
clasa d2. publice de bază publică:
int k;
>;
/ * D3 patrimoniu ca d1 și d2. Acest lucru înseamnă că d3 există două copii ale bazei! * /
clasa d3. d1 publică, publică d2:
int m;
>;
int main ()
d3 d;
i.d. = 10; // incertitudine, care i.
D.J = 20;
D.K = 30;
d.m = 40;
// incertitudinea pe care i.
cout < cout < cout < return 0;
>

Există două modalități de remediere a programului. Primul este de a utiliza operatorul de definire a domeniului pentru variabila i cu selectarea manuală ulterioară a unuia dintre i. De exemplu, următoarea versiune a programului este compilat și executat după cum este necesar:

#include
publice de bază de clasă:
int i;
>;
// d1 moștenește de bază.
clasa d1. publice de bază publică:
int j;
>;
// d2 moștenește de bază.
clasa d2. publice de bază publică:
int k;
>;
/ * D3 patrimoniu ca d1 și d2. Acest lucru înseamnă că d3 există două copii ale bazei! * /
clasa d3. d1 publică, publică d2:
int m;
>;
int main ()
d3 d;
d.d2 :: i = 10; // domeniu de aplicare este definit, i folosit la d2
D.J = 20;
D.K = 30;
d.m = 40;
// domeniu de aplicare este definit, i folosit la d2
cout < cout < cout < return 0;
>

După cum se poate observa din declarația domeniului de aplicare. Programul selectat manual versiune a bazei d2-clasă. Cu toate acestea, această soluție dă naștere la o întrebare mai profundă: ce se întâmplă dacă aveți nevoie doar de o copie a bazei de clasă? Există vreo modalitate de a preveni, inclusiv chenie două copii, clasa d3? După cum s-ar putea ghici, răspunsul la această întrebare este da. Soluția este obținută prin utilizarea clasa de bază virtuală.

Atunci când două sau mai multe clase sunt generate dintr-o clasă de bază comună poate predot porți de includere a mai multor copii ale clasei de bază în obiectul copil al acestor clase pe clase de baza virtuale Ad MENT cu moștenirea sa. De exemplu, aici este o altă versiune a programului anterior, care d3 conține doar o copie a bazei de clasă:

#include
publice de bază de clasă:
int i;
>;
// d1 moștenește baza ca virtuală
clasa d1. virtuale publice de bază publică:
int j;
>;
// d2 moștenește baza ca virtuală
clasa d2. virtuale publice de bază publică:
int k;
>;
/ * D3 patrimoniu ca și d2 d1. Cu toate acestea, d3, există doar o singură copie a bazei! * /
clasa d3. d1 publică, publică d2:
int m;
>;
int main ()
d3 d;
i.d. = 10; // nu mai există incertitudine
D.J = 20;
D.K = 30;
d.m = 40;
cout < cout < cout < return 0;
>

După cum se poate observa, cuvântul cheie virtual este precedat de o specificație de clasă derivată. Acum, atât clasa d1 și d2 moștenesc clasa de bază ca virtuale. Orice moștenire multiplă cu participarea lor genereaza acum includerea doar o copie a bazei de clasă. Prin urmare, în sala de clasă d3
există doar o singură copie a clasei de bază și, prin urmare, i.d. = 10 este expresia NYM nu mai ambiguă.

Trebuie avut în vedere un alt fapt: deși ambele clase de d1 și d2 este folosit ca o clasă de bază virtuală, dar fiecare clasă d1 obiect sau d2 va conține o bază. De exemplu, următorul cod este absolut corect:

// clasa definiție de tip d1
myclass d1;
myclass.i = 100;

clase de bază convenționale și virtuale diferă unul de altul numai atunci când a oricărui obiect moștenește clasa de bază mai mult decât o dată. Atunci când se utilizează clasa de bază virtuală este doar o copie a clasei de bază este conținută în obiectul. În cazul clasei de bază convenționale în obiect poate conține mai multe copii.