Johdatus virtuaaliseen avainsanaan C ++: ssa

C ++: n virtuaalista avainsanaa käytetään virtuaalitoiminnon luomiseen C ++: ssa. Virtuaalifunktio on vanhemmaluokkafunktio, jonka haluamme määritellä uudelleen lapsiluokassa. Virtuaalifunktio ilmoitetaan käyttämällä avainsanaa virtual. Kun määrittelemme virtuaalitoiminnon, avainsanan virtuaali on jatkettava funktion ilmoituksessa. Virtuaalinen avainsana kertoo kääntäjälle myöhäisen sidonnan tai dynaamisen linkityksen toiminnolle.

Yhden osoittimen on viitattava kaikkiin luokkien kohteisiin. Siksi superluokalle luodaan osoitin viitaamaan kaikkiin johdetun luokan objekteihin ja sitten superluokan osoitin sisältää johdetun luokan objektin osoitteen. Suorita aina superluokkatoiminto. Joten tämän ratkaisemiseksi käytämme virtuaalitoimintoa. Joten kun virtuaalifunktio luodaan superluokassa, C ++ -kääntäjä tunnistaa, mikä toiminto suoritetaan ajon aikana, ja funktion tunnistaminen vie sen objektityypin perusteella, johon superluokan osoitin osoittaa.

Virtuaalitoiminto

Syntaksin virtuaalitoiminnot on annettu alla:

Syntaksi

class name_class
(
public :
virtual return fun(arg1, arg2, ..)
(
//code inside the function
)
)

Kuten syntaksissa, fun () julistaa virtuaalisen avainsanan avulla, mikä tarkoittaa, että lapsiluokka voi määritellä samat menetelmät uudelleen.

Ohjelma 1:

#include
using namespace std;
class A
(
public:
void disp()
(
cout << " Message from the class A\n ";
)
);
class B :public A
(
public:
void disp()
(
cout << "Message from the class B\n";
)
);
int main()
(
A* obj1; // super class pointer
B obj2; // child class object
obj1 = &obj2;
obj1-> disp(); // Late Binding Occurs
)

lähtö:

Yllä olevassa ohjelmassa superluokka A, jolla on funktio disp (), joka kirjoitetaan johdettuun luokkaan B. Päätoiminnossa displa () -menetelmä on obj1-kohteen kutsuminen (joka on dynaaminen sidonta tai myöhäinen sitominen. Dynaaminen sidonta) on prosessi, jossa suoritetaan mikä erityinen suoritettava funktio päätetään ajoaikana) ja luokan A dis () toiminto suoritetaan.

Ohjelma 2:

#include
using namespace std;
class A
(
public:
virtual void disp()
(
cout << " Message from the class A \n ";
)
);
class B :public A
(
public:
void disp()
(
cout << "Message from the class B\n";
)
);
int main()
(
A* obj1; // super class pointer
B obj2; // child class object
obj1 = &obj2;
obj1-> disp(); // Dynamic Binding Ocuurs
)

lähtö:

Yllä oleva ohjelmakoodi on ohjelman 1 muutos, dispi () -toiminto määritetään avainsanalla virtuaali ja nyt kun obj1, joka kutsui dispi () -toimintoa, lapsiluokan B dispi () -toiminto suoritetaan.

Ohjelma 3:

#include
using namespace std;
class A
(
public:
virtual void disp()
(
cout << " Message from the class A\n ";
)
);
class B :public A
(
public:
virtual void disp()
(
cout << "Message from the class B\n";
)
);
int main()
(
A* obj1; // super class pointer
B obj2; // child class object
obj1 = &obj2;
obj1-> disp(); // Dynamic Binding Ocuurs
)

lähtö:

Yllä oleva ohjelmakoodi on ohjelman 2 muutos, joka on dis () -toiminto, joka määritellään uudelleen myös luokan B virtuaalisella avainsanalla ja nyt kun obj1 kutsuu dispi () -toimintoa, dispi () -toiminto lastenluokassa B suoritetaan.

Seuraavaksi kirjoitamme puhtaan virtuaalitoiminnon ohjelman. Puhdas virtuaalifunktio on toiminto, jolle donilla ei ollut toteutuksia. Puhdasta virtuaalifunktiota kutsutaan myös abstraktiksi virtuaalifunktioksi. Puhtaan virtuaalitoiminnon ilmoitus antaa 0, kuten alla olevassa koodissa esitetään -

Ohjelma 4:

#include
using namespace std;
class A
(
public:
virtual void disp()=0;
);
class B :public A
(
public:
void disp()
(
cout << "Message from the class B\n";
)
);
int main()
(
A* obj1; // super class pointer
B obj2; // child class object
obj1 = &obj2;
obj1-> disp(); // Dynamic Binding Ocuurs
)

lähtö:

Virtuaaliavainsanan edut C ++: ssa

  • Virtuaalitoimintoja käytetään suorituksenaikaisen polymorfismin saavuttamiseen.
  • Jos luokka on johdettu luokasta, jolla on virtuaalifunktio, funktion määritelmä voidaan määritellä uudelleen johdetussa luokassa.

Virtuaalisen avainsanan säännöt C ++: ssa

  • C ++: n virtuaalinen avainsana käyttää toimintoilmoitusta.
  • Virtuaalisten toimintojen on oltava luokan jäseniä.
  • Objektiosoittimien kautta päästetty virtuaalitoiminto.
  • Virtuaalitoimintoa ei voida julistaa staattiseksi.
  • Virtuaalitoiminto voi olla ystäviä toisesta luokasta.
  • Jos virtuaalitoimintoa ei käytetä superluokassa, niin voimme myös määritellä sen superluokassa.
  • Yläluokan ja lapsiluokkien virtuaalitoiminnon allekirjoituksen tulisi olla sama, ns. Funktio-ohitus, muuten, jos molemmat toiminnot ovat samalla nimellä, mutta eri allekirjoituksella, sitä pidetään C ++: n ylikuormitettuina funktioina.
  • Meillä voi olla virtuaalinen tuhoaja, mutta meillä ei voi olla virtuaalista rakentajaa.

johtopäätös

  • C ++: n virtuaalista avainsanaa käytetään virtuaalitoiminnon luomiseen C ++: ssa.
  • Virtuaalifunktio on vanhemmaluokkafunktio, jonka haluamme määritellä uudelleen lapsiluokassa.
  • Yhden osoittimen on viitattava kaikkiin luokkien kohteisiin.
  • Superluokan osoitin sisältää johdetun luokan objektin osoitteen. Suorita aina superluokkatoiminto.
  • Virtuaalisten toimintojen on oltava luokan jäseniä, niiden on oltava luokan jäseniä, niitä ei voida julistaa staattisiksi, joihin pääsee objektiohjainten kautta.
  • Yläluokan ja lapsiluokkien virtuaalitoiminnon allekirjoituksen tulisi olla sama, ns. Funktio-ohitus, muuten, jos molemmat toiminnot ovat samalla nimellä, mutta eri allekirjoituksella, sitä pidetään C ++: n ylikuormitettuina funktioina.

Suositellut artikkelit

Tämä on opas virtuaaliseen avainsanaan C ++: ssa. Tässä keskustellaan C ++: n virtuaalisen avainsanan johdannosta ja eduista sekä sen virtuaalitoiminnon syntaksista. Voit myös käydä läpi muiden ehdotettujen artikkeleidemme saadaksesi lisätietoja -

  1. Menetelmän ohittaminen C #: ssä
  2. Perintö C #: ssä
  3. C # komennot
  4. Java-komennot
  5. Ylivoimainen Java
  6. Polymorfismi Java
  7. C ++: n 11 tärkeintä ominaisuutta ja hyötyä

Luokka:

Ohjelmistokehitys