Inleiding tot de abstracte klasse in C ++
Een klasse is een gegevenstype dat door de gebruiker wordt gedefinieerd en heeft zijn eigen gegevensleden en functies. De leden en functies kunnen worden gebruikt door een object of instantie van die klasse te maken. Geheugen wordt alleen aan een klasse toegewezen wanneer een object wordt gemaakt.
Wanneer we bepaalde gedragingen of kenmerken van de ene klasse naar de andere klasse willen afleiden, gebruiken we het concept van overerving. Dit is de methode om enkele eigenschappen van de bovenliggende klasse (basisklasse) naar onderliggende klasse (afgeleide klasse) te erven.
Bij de implementatie en overerving van klassen, wanneer we dezelfde functies zowel in de basisklasse als de afgeleide klasse willen definiëren, gebruiken we het sleutelwoord 'virtueel' samen met de basisklasse-functie. Deze 'virtuele' functie geeft aan dat dezelfde functie opnieuw wordt gedefinieerd of genegeerd in de afgeleide klasse.
Een abstracte klasse is een klasse met pure virtuele functie. Wat is nu een pure virtuele functie? Een pure virtuele functie is een virtuele functie die geen body heeft en wordt toegewezen als 0. Dit type functie wordt geïmplementeerd wanneer we een functie nodig hebben maar we weten momenteel niet wat de functie ervan is. Deze functie moet worden geïmplementeerd of gedefinieerd in de afgeleide klasse. Zo niet, dan wordt de afgeleide klasse ook een abstracte klasse.
Een pure virtuele functie is als volgt gedefinieerd:
virtual void func () = 0;
Voorbeeld van abstracte klasse in C ++
Hier bespreken we Voorbeeld van abstracte klasse in C ++ met details:
#include
using namespace std;
class Sample_Class (
int a = 5;
public:
virtual void sample_func() = 0;
void print_func() (
cout << a;
)
);
class Derived_Class : public Sample_Class (
public:
void sample_func() (
cout << "pure virtual function is implemented";
)
);
int main() (
Derived_Class d_object;
d_object.sample_func();
)
Output:
Hier is Sample_Class de basisklasse en Derived_Class is afgeleid van de Sample_Class. Een pure virtuele functie genaamd sample_func () wordt gedeclareerd in de basisklasse. Het wordt toegewezen aan 0, wat betekent dat het niemand heeft en dat er niets in de functie is geïmplementeerd. De basisklasse is dus een abstracte klasse geworden omdat deze een pure virtuele functie heeft. Aanvankelijk, wanneer de Derived_Class is afgeleid van de basisklasse, wordt deze ook een abstracte klasse. Maar in de afgeleide klasse wordt de klasse sample_func () gedefinieerd, waardoor wordt voorkomen dat de afgeleide klasse een abstracte klasse wordt. Wanneer het afgeleide klasseobject wordt gemaakt en de functie wordt aangeroepen, krijgen we de uitvoer afgedrukt als 'pure virtuele functie is geïmplementeerd'.
Een abstracte klasse kan niet worden geïnstantieerd, wat betekent dat we geen instantie of object voor een abstracte klasse kunnen maken. Het object kan niet worden gemaakt omdat de klasse niet volledig is geïmplementeerd. Het is eigenlijk een basis voor een klasse die later volledig wordt geïmplementeerd. Maar verwijzingen of verwijzingen kunnen worden gemaakt voor een abstracte klasse. Deze aanwijzer kan worden gebruikt om de afgeleide klassenfuncties aan te roepen. Een abstracte klasse kan andere gegevensleden en functies hebben die vergelijkbaar zijn met normale klassenimplementatie, samen met een pure virtuele functie.
Het bovenstaande punt kan worden verklaard via het onderstaande programma
class Class1 (
int a;
public:
virtual void func1() = 0;
void func2() (
cout << "base class";
)
);
class Class2 : public Class1 (
public:
void func1() (
cout << "func1 in derived class";
)
);
int main() (
Class1 b; //---------- > this line will cause an error
//Class1 *b = new Class2(); //---------- > pointer can be created, so this line is correct
// b -> func1();
)
Output:
Hier krijgen we een foutmelding omdat een object niet kan worden gemaakt voor abstracte klasse.
In plaats daarvan kan de tweede en derde coderegel worden geïmplementeerd, kan een aanwijzer worden gemaakt en kan deze worden gebruikt om de afgeleide klassenfunctie aan te roepen.
Hier is Class1 in de bovenstaande functie de basisklasse en omdat het een pure virtuele functie (func1) heeft, is het een abstracte klasse geworden. Klasse2 is afgeleid van de bovenliggende klasse Klasse1. Func1 is gedefinieerd in de afgeleide klasse. In de hoofdfunctie krijgen we een foutmelding als we een object van het type base class proberen te maken, omdat objecten niet kunnen worden gemaakt voor abstracte klasse. Terwijl wanneer we proberen een aanwijzer van het type base class te maken, deze met succes wordt gemaakt en we deze naar de afgeleide klasse kunnen verwijzen. Deze aanwijzer kan worden gebruikt om de afgeleide klassenfunctie aan te roepen.
Een abstracte klasse kan een constructor hebben die lijkt op een normale klasse-implementatie. In het geval van de destructor kunnen we een pure virtuele destructor verklaren. Het is belangrijk om een destructor te hebben om het geheugen te verwijderen dat aan de klasse is toegewezen. Pure virtuele destructor is een destructor die is toegewezen aan 0, maar moet door dezelfde klasse worden gedefinieerd, omdat destructor meestal niet wordt genegeerd.
Voorbeeld van implementatie van constructor en destructor voor abstracte klasse in C ++
Hier bespreken we Voorbeeld van abstracte klasse in C ++ met details:
class Base (
public:
int a;
virtual void func1() = 0;
// Constructor
Base(int i) (
a = i;
)
// Pure Virtual destructor
virtual ~Base() = 0;
);
// Pure virtual destructor is defined
Base :: ~Base() (
cout << "Pure virtual destructor is defined here" << endl;
)
class Derived : public Base (
int b;
public:
// Constructor of derived class
Derived(int x, int y) : Base(y) ( b = x; )
// Destructor of derived class
~Derived() (
cout << "Derived class destructor" << endl;
)
//Definition for pure virtual function
void func1() (
cout << "The value of a is " << a << " and b is " << b << endl;
)
);
int main() (
Base *b = new Derived(5, 10);
b->func1();
delete b;
)
Uitgang :
Hier, in het bovenstaande voorbeeld, is de basisklasse een abstracte klasse met pure virtuele functie func1 (), een constructor en een pure virtuele destructor. De pure virtuele functie wordt gedefinieerd in de afgeleide klasse, waardoor wordt voorkomen dat de afgeleide klasse een abstracte klasse wordt. De pure virtuele destructor wordt gedefinieerd door de Base-klasse buiten de klasse. Als we de lidfunctie van een klasse buiten de klasse willen definiëren, moet de operator voor bereikresolutie worden gebruikt zoals in het voorbeeld. Er wordt een aanwijzer van het type basisklasse gemaakt die naar de afgeleide klasse verwijst. Wanneer destructor wordt aangeroepen met behulp van 'delete', wordt eerst de afgeleide klasse destructor aangeroepen en vervolgens de basisklasse destructor.
Conclusie
Daarom kunnen we, om alles over een abstracte klasse te compileren, zeggen dat de abstracte klasse een klasse is met een pure virtuele functie. Deze pure virtuele functie moet worden gedefinieerd in de afgeleide klasse, zo niet, dan wordt de afgeleide klasse ook een abstracte klasse. Het object kan niet worden gemaakt voor abstracte klasse, maar er kan een aanwijzer worden gemaakt die naar de afgeleide klasse kan worden gewezen.
Aanbevolen artikelen
Dit is een gids voor Abstract Class in C ++. Hier bespreken we de inleiding tot de abstracte klasse en de implementatie van constructor en destructor in C ++ samen met zijn voorbeeld. U kunt ook de volgende artikelen bekijken voor meer informatie-
- Abstracte klasse in Python
- Abstracte klasse in Java
- Constructor en Destructor in C ++
- Overschrijven in C ++
- Overschrijven in Java
- Top 11 kenmerken en voordelen van C ++