Introduktion till virtuellt nyckelord i C ++
Ett virtuellt nyckelord i C ++ används för att skapa en virtuell funktion i C ++. Den virtuella funktionen är den överordnade klassfunktionen som vi vill omdefiniera i barnklassen. Den virtuella funktionen deklareras med hjälp av nyckelordet virtual. När vi definierar den virtuella funktionen ska nyckelordet virtuella fortsätta i deklarationen av funktionen. Det virtuella nyckelordet berättar kompilatorn att utföra sen bindning eller dynamisk koppling på funktionen.
Enkel pekaren krävs för att hänvisa till alla objekt i olika klasser. Därför skapas pekaren på superklassen för att hänvisa till alla objekt i den härledda klassen och sedan innehåller superklasspekaren adressen till objektet i den härledda klassen kör alltid superklassfunktionen. Så för att lösa detta använder vi den virtuella funktionen. Så när den virtuella funktionen skapas i superklassen identifierar C ++ -kompilatorn vilken funktion som ska köras vid körning och identifieringen av funktionen tar baserat på den typ av objekt som superklassens pekare pekar.
Virtuell funktion
Syntaxens virtuella funktioner anges nedan:
Syntax
class name_class
(
public :
virtual return fun(arg1, arg2, ..)
(
//code inside the function
)
)
Som i syntaxen förklarar det roliga () med det virtuella nyckelordet, vilket innebär att barnklassen kan omdefiniera samma metoder.
Program 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
)
Produktion:
I ovanstående program överklass A som har funktionen disp (), som skrivs om i den härledda klass B. I huvudfunktionen anropar metoden disp () objektet obj1 (som är en dynamisk bindning eller sen bindning. Dynamisk bindning) är en process där den specifika funktionen att utföra bestämmer vid körningstiden) och disp () -funktionen för klass A utförs.
Program 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
)
Produktion:
Ovanstående programkod är ändringen av programmet 1, disp () -funktionen definieras med nyckelordet virtuellt och nu när obj1 som kallar disp () -funktionen exekveras disp () -funktionen för barnklass B.
Program 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
)
Produktion:
Ovanstående programkod är ändringen av programmet 2, disp () -funktionen som också omdefinieras med nyckelordet virtuellt i klass B och nu när obj1 som kallar disp () -funktionen, disp () -funktionen för barnklass B avrättas.
Därefter skriver vi programmet för den rena virtuella funktionen. Den rena virtuella funktionen är en funktion för vilken don inte hade implementeringar. Den rena virtuella funktionen kallas också en abstrakt virtuell funktion. Den rena virtuella funktionsdeklarationen tilldelar 0, som visas i koden nedan -
Program 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
)
Produktion:
Fördelar med virtuellt nyckelord i C ++
- Virtuella funktioner används för att uppnå runtime polymorfism.
- Om en klass härrör från en klass som har en virtuell funktion, kan funktionsdefinitionen omdefinieras i den härledda klassen.
Regler för virtuellt nyckelord i C ++
- Det virtuella nyckelordet i C ++ används i funktionsdeklarationen.
- Virtuella funktioner måste vara klassmedlemmar.
- Den virtuella funktionen nås via objektpekare.
- Den virtuella funktionen kan inte deklareras som statisk.
- Den virtuella funktionen kan vara vänner från en annan klass.
- Om den virtuella funktionen inte används i superklassen kan vi också definiera den i superklassen.
- Underteckningen av en virtuell funktion av superklassen och barnklasserna bör vara densamma, så kallad funktionsöverskridande, annars om de två funktionerna med samma namn men olika signatur, det betraktas som de överbelastade funktionerna i C ++.
- Vi kan ha en virtuell destruktor men inte ha en virtuell konstruktör.
Slutsats
- Ett virtuellt nyckelord i C ++ används för att skapa en virtuell funktion i C ++.
- Den virtuella funktionen är den överordnade klassfunktionen som vi vill omdefiniera i barnklassen.
- Enkel pekaren krävs för att hänvisa till alla objekt i olika klasser.
- Superklasspekaren innehåller adressen till objektet i den härledda klassen kör alltid superklassfunktionen.
- De virtuella funktionerna måste vara klassmedlemmar, måste vara klassmedlemmar, kan inte deklareras som statiska, åtkomst via objektpekare.
- Underteckningen av en virtuell funktion av superklassen och barnklasserna bör vara densamma, så kallad funktionsöverskridande, annars om de två funktionerna med samma namn men olika signatur betraktas det som de överbelastade funktionerna i C ++.
Rekommenderade artiklar
Detta är en guide till det virtuella nyckelordet i C ++. Här diskuterar vi introduktionen och fördelarna med virtuella nyckelord i C ++ tillsammans med dess syntax för den virtuella funktionen. Du kan också gå igenom våra andra föreslagna artiklar för att lära dig mer -
- Metodöverskridande i C #
- Arv i C #
- C # Kommandon
- Java-kommandon
- Övergripande i Java
- Polymorfism i Java
- Topp 11 funktioner och fördelar med C ++