Virtuaalinen toiminto C ++ on jäsenfunktio perusluokassa, jonka määrittelemme uudelleen johdetussa luokassa. Tämä artikkeli auttaa sinua tutustumaan käsitteeseen yksityiskohtaisesti. Seuraavat viitteet käsitellään tässä artikkelissa,
- Mikä on virtuaalitoiminto?
- Säännöt virtuaalitoiminnolle C ++: ssa
- Mikä on sitova?
- Varhainen sitominen
- Myöhäinen sitoutuminen
- Puhdas virtuaalitoiminto
- Abstrakti luokka
- Esimerkki virtuaalitoiminnosta
Joten aloitetaan tämän artikkelin kanssa virtuaalitoiminnosta C ++: ssa
Mikä on virtuaalitoiminto?
Virtuaalifunktio on perusluokan jäsenfunktio, jonka määrittelemme uudelleen johdetussa luokassa. Se ilmoitetaan virtuaalisella avainsanalla. Kun virtuaalitoimintoa sisältävä luokka peritään, johdettu luokka määrittää virtuaalitoiminnon uudelleen omien tarpeidensa mukaan.
Siirrytään tähän artikkeliin virtuaalitoiminnosta C ++: ssa
Virtuaalitoiminnon säännöt C ++: ssa:
- Ne määritellään aina perusluokassa ja ohitetaan johdetussa luokassa, mutta johdetun luokan ohittaminen ei ole pakollista.
- Virtuaalitoiminnot on ilmoitettava luokan julkisessa osiossa.
- Ne eivät voi olla staattisia tai ystävätoimintoja eivätkä voi olla toisen luokan virtuaalisia toimintoja.
- Virtuaalitoimintoja tulisi käyttää osoittimen avulla, jotta saavutettaisiin ajoaikapolymorfismi.
Siirrytään tähän artikkeliin virtuaalitoiminnosta C ++: ssa.
Mikä on sitova?
Funktioiden sitominen tarkoittaa, että missä tahansa toimintokutsu on, kääntäjän on tiedettävä, mihin funktion määritelmään se tulisi sovittaa. Tämä riippuu kunkin toimintoilmoituksen allekirjoituksesta ja tehdyistä tehtävistä. Kääntäjän on myös tiedettävä, että kun tämä funktion kutsun ja oikean määritelmän valitseminen tapahtuu.
Siirrytään tähän artikkeliin virtuaalitoiminnosta C ++: ssa
Varhainen sidonta
Varhainen sitominen on ilmiö, jossa päätös erilaisten funktiokutsujen sovittamisesta tapahtuu itse kääntöhetkellä ja kääntäjä yhdistää linkin suoraan osoitteisiin. Se tunnetaan myös nimellä staattinen sitova tai kokoamisajan sitova.
- Kuten tiedämme, kirjoitamme koodin korkean tason kielellä
- Sitten kääntäjä muuntaa tämän matalalle kielelle, jota tietokone ymmärtää, lähinnä konekieleksi kokoamisen aikana
- Varhaisessa sidonnassa kääntäjä antaa toiminnon ilmoituskäskyn osoitteen suoraan funktion kutsukäskylle
- Siten, kuten nimestä voi päätellä, sidonta tapahtuu hyvin aikaisin ennen ohjelman suorittamista.
Esimerkki
#include nimitilan käyttäminen vakioluokka Eläimet {public: void sound () {cout<< 'Genric animal sound' << endl } } class Cats: public Animals { public: void sound() { cout << 'Cat meow' <ääni () // varhaisen sidonnan palautus 0} Tuotos
selvennykset ioni
Tässä esimerkissä loimme osoittimen a pääluokalle Eläimet. Sitten kirjoittamalla a = & c, osoitin 'a' alkoi viitata Cats-luokan objektiin c.
a -> ääni () - Kutsuessaan funktion äänen (), joka on molemmissa luokissa osoittimen 'a' avulla, pääluokan toiminto sai kutsun, vaikka osoitin viittaa luokan Kissat objektiin .
Tämä johtuu varhaisesta sitomisesta. Tiedämme, että ”a” on vanhempien luokan osoitin, joka viittaa lapsiluokan kohteeseen. Koska varhainen sidonta tapahtuu käännösaikana, siis kun kääntäjä näki, että 'a' on yläluokan osoitin, se sovitti kutsun vanhemman luokan 'ääni ()' -funktioon etsimättä objektia osoittimen sitä viittaa.
Siirrytään tähän artikkeliin virtuaalitoiminnosta C ++: ssa
Myöhäinen sidonta
Myöhäisessä sidonnassa kääntäjä tunnistaa objektin ajon aikana ja sovittaa sitten funktiokutsun oikeaan funktioon. Se tunnetaan myös nimellä Dynamic Binding tai Runtime Binding.
Myöhäinen sitoutuminen yllä olevassa ongelmassa voidaan ratkaista käyttämällä virtuaalista avainsanaa perusluokassa. Katsotaanpa, miten tämä tapahtuu, käyttämällä yllä olevaa esimerkkiä itse, mutta lisäämällä vain virtuaalinen avainsana.
Esimerkki
#include nimitilan käyttäminen vakioluokka Eläimet {public: virtual void sound () {cout<< 'Genric aniaml sound' << endl } } class Cats: public Animals { public: void sound() { cout << 'Cats meow' <ääni () paluu 0} Tuotos
Selitys
Täällä perusluokan funktion ääni () tehdään virtuaaliseksi, joten kääntäjä suorittaa nyt myöhäisen sidonnan tälle toiminnolle. Ääni () -funktion funktiokutsu sovitetaan nyt funktion määritelmään ajon aikana. Koska kääntäjä tunnistaa osoittimen 'a' viittaavan johdetun luokan Cats objektiin 'c', se kutsuu luokan Cats ääni () -funktiota.
Siirrytään tähän artikkeliin virtuaalitoiminnosta C ++: ssa
Puhdas virtuaalitoiminto
Puhdas virtuaalifunktio C ++: ssa on virtuaalifunktio, jolle meillä ei ole toteutusta, vaan ilmoitamme sen vain. Puhdas virtuaalifunktio ilmoitetaan antamalla ilmoitukseen 0.
virtuaalinen tyhjä ääni () = 0
Tässä ääni () on puhdas virtuaalifuktio.
Siirrytään tähän artikkeliin virtuaalitoiminnosta C ++: ssa
Abstrakti luokka
Abstrakti luokka määritellään luokaksi, jossa on yksi tai useampi puhdas virtuaalinen toiminto. Kuten edellä selitettiin, puhdas virtuaalifunktio on virtuaalinen jäsenfunktio, joka on merkitty ilman toteutusta. Sitä ei ole mahdollista toteuttaa luokassa annetuilla tiedoilla, mukaan lukien kaikki perusluokat. Abstrakti luokka tunnetaan myös abstraktina perusluokkana.
Esimerkki
#include nimitilan käyttäminen vakioluokka Työntekijä // abstrakti perusluokka {virtuaalinen int getSalary () = 0 // puhdas virtuaalifunktio} luokka Työntekijä_1: julkinen työntekijä {int palkka julkinen: työntekijä_1 (int s) {palkka = s} int getSalary () {palkkapalkka}} luokka Työntekijä_2: julkinen työntekijä {int palkka julkinen: Työntekijä_2 (int t) {palkka = t} int getSalary () {paluupalkka}} int pää () {Työntekijä_1 e1 (5000) Työntekijä_2 e2 (3000) int a, ba = e1.getSalary () b = e2.getSalary () cout<< 'Salary of Developer : ' << a << endl cout << 'Salary of Driver : ' << b << endl return 0 } Tuotos
Selitys
‘GetSalary ()’ -funktio työntekijän luokassa on puhdas virtuaalifunktio. Koska Työntekijä-luokka sisältää puhtaan virtuaalitoiminnon, se on siis abstrakti perusluokka.
Koska puhdas virtuaalifunktio on määritelty alaluokissa, funktio ‘getSalary ()’ on määritelty sekä työntekijän luokan aliluokissa eli työntekijä_1 että työntekijä_2.
Siirrytään tähän artikkeliin virtuaalitoiminnosta C ++: ssa
minun sql-oppaat aloittelijoille
Esimerkki virtuaalitoiminnosta
#include käyttämällä nimitilan vakioluokan perustaa {public: void function_1 () {cout<< 'base class function 1n' } virtual void function_2() { cout << 'base class function 2n' } virtual void function_3() { cout << 'base class function 3n' } virtual void function_4() { cout << 'base class function 4n' } } class derived : public base { public: void function_1() { cout << 'derived class function 1n' } void function_2() { cout << 'derived class function 2n' } void function_4(int x) { cout function_2 () ptr-> function_3 () ptr-> function_4 ()} Tuotos
Selitys
Funktion funktiolle_1 () kutsutaan funktion perusluokan versio, funktio_2 () ohitetaan johdetussa luokassa, joten johdettua luokan versiota kutsutaan, funktiota_3 () ei ohiteta johdetussa luokassa ja se on virtuaalinen funktio, joten kutsutaan perusluokan versiota, samoin funktiota 4 () ei ohiteta, joten kutsutaan perusluokan versiota.
Siksi olemme päässeet tämän artikkelin 'Virtuaalitoiminto C ++: ssa' loppuun. Jos haluat oppia lisää, tutustu Edureka, luotettava verkko-oppimisyritys. Edurekan Java J2EE- ja SOA-koulutus- ja sertifiointikurssit on suunniteltu kouluttamaan sekä ydin- että edistyneitä Java-konsepteja sekä erilaisia Java-kehyksiä, kuten Hibernate & Spring.
Onko sinulla kysymys meille? Mainitse se tämän blogin kommenttiosassa ja otamme sinuun yhteyttä mahdollisimman pian.