Introducere în clasa abstractă în C ++
O clasă este un tip de date definit de utilizator și are propriile sale date și funcții. Membrii și funcțiile pot fi utilizate prin crearea unui obiect sau instanță a clasei respective. Memoria este alocată pentru o clasă numai atunci când este creat un obiect.
Când dorim să derivăm anumite comportamente sau caracteristici de la o clasă la alta, folosim conceptul de moștenire. Aceasta este metoda de moștenire a puținelor proprietăți de la clasa părinte (clasa de bază) la clasa copil (clasa derivată).
În implementarea clasei și moștenirea, atunci când dorim să definim aceleași funcții atât în clasa de bază, cât și în cea derivată, folosim cuvântul cheie „virtual” împreună cu funcția clasei de bază. Această funcție „virtuală” specifică faptul că aceeași funcție este redefinită sau suprasolicitată în clasa derivată.
O clasă abstractă este o clasă cu funcție virtuală pură. Acum, ce este o funcție virtuală pură? O funcție virtuală pură este o funcție virtuală care nu are corp și este atribuită ca 0. Acest tip de funcții este implementat atunci când avem nevoie de o funcție, dar nu știm în prezent care este funcția sa. Această funcție trebuie implementată sau definită în clasa derivată. Dacă nu, atunci clasa derivată devine și o clasă abstractă.
O funcție virtuală pură este definită după cum urmează:
virtual void func () = 0;
Exemplu de clasă abstractă în C ++
Aici, discutăm Exemplu de clasă abstractă în C ++ cu detalii:
#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();
)
ieşire:
Aici, Sample_Class este clasa de bază, iar Derive_Class este derivată din Clasa Sample_Class. O funcție virtuală pură numită sample_func () este declarată în clasa de bază. Este alocat la 0, ceea ce înseamnă că nu are nimeni și nimic nu este implementat în cadrul funcției. Astfel, clasa de bază a devenit o clasă abstractă, deoarece are o funcție virtuală pură. Inițial, atunci când Clasa Derivată este derivată din clasa de bază, devine și o clasă abstractă. Dar în clasa derivată, clasa sample_func () este definită, ceea ce împiedică clasa derivată să devină o clasă abstractă. Când obiectul clasei derivate este creat și funcția este numită, vom obține imprimarea ieșirii ca fiind „implementată funcția virtuală pură”.
O clasă abstractă nu poate fi inițiată, ceea ce înseamnă că nu putem crea o instanță sau un obiect pentru o clasă abstractă. Obiectul nu poate fi creat deoarece clasa nu este implementată complet. Este de fapt o bază pentru o clasă care este implementată complet mai târziu. Dar indicatoarele sau referințele pot fi create pentru o clasă abstractă. Acest indicator poate fi folosit pentru a apela funcțiile clasei derivate. O clasă abstractă poate avea alți membri de date și funcții similare cu implementarea normală a clasei, împreună cu o funcție virtuală pură.
Punctul de mai sus poate fi explicat prin programul de mai jos
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();
)
ieşire:
Aici vom primi o eroare, deoarece un obiect nu poate fi creat pentru o clasă abstractă.
În schimb, se poate implementa o linie de cod 2 și 3, un pointer poate fi creat și poate fi folosit pentru a apela funcția clasei derivate.
Aici, în funcția de mai sus, Class1 este clasa de bază și, deoarece are o funcție virtuală pură (func1), a devenit o clasă abstractă. Clasa 2 este derivată din clasa părinte Clasa1. Funcția este definită în clasa derivată. În funcția principală, atunci când încercăm să creăm un obiect al clasei de bază de tip, vom primi o eroare, deoarece obiectele nu pot fi create pentru o clasă abstractă. Întrucât atunci când încercăm să creăm un indicator de tipul clasei de bază, acesta va fi creat cu succes și îl putem indica către clasa derivată. Acest indicator poate fi folosit pentru a apela funcția clasei derivate.
O clasă abstractă poate avea un constructor similar cu implementarea normală a clasei. În cazul distrugătorului, putem declara un distrugător virtual pur. Este important să aveți un distrugător pentru a șterge memoria alocată clasei. Destructorul virtual pur este un distrugător care este atribuit la 0, dar trebuie definit de aceeași clasă, deoarece de obicei distrugătorul nu este suprasolicitat.
Exemplu de implementare a constructorului și destructorului pentru clasa abstractă în C ++
Aici, discutăm Exemplu de clasă abstractă în C ++ cu detalii:
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;
)
Rezultat :
Aici, în exemplul de mai sus, Clasa de bază este o clasă abstractă cu funcția virtuală pur func1 (), un constructor și un pur distrugător virtual. Funcția virtuală pură este definită în clasa derivată, împiedicând astfel clasa derivată să devină o clasă abstractă. Distrugătorul virtual pur este definit de clasa de bază din afara clasei. Dacă dorim să definim funcția de membru a unei clase în afara clasei, ar trebui să se utilizeze operatorul de rezolvare a domeniului, așa cum se arată în exemplu. Un pointer de tipul clasei de bază este creat și indicat spre clasa derivată. Când se numește distrugător folosind „șterge”, mai întâi se numește distrugătorul clasei derivate și apoi se numește distrugătorul clasei de bază.
Concluzie
Prin urmare, pentru a compila totul despre o clasă abstractă, putem spune că clasa abstractă este o clasă cu o funcție virtuală pură. Această funcție virtuală pură trebuie definită în clasa derivată, dacă nu atunci clasa derivată devine și o clasă abstractă. Obiectul nu poate fi creat pentru o clasă abstractă, dar poate fi creat indicatorul care poate fi îndreptat către clasa derivată.
Articole recomandate
Acesta este un ghid pentru clasa abstractă în C ++. Aici discutăm introducerea în clasa abstractă, precum și implementarea constructorului și destructorului în C ++ împreună cu exemplul acesteia. De asemenea, puteți consulta următoarele articole pentru a afla mai multe-
- Clasă abstractă în Python
- Clasă abstractă în Java
- Constructor și distrugător în C ++
- Suprapunere în C ++
- Suprasolicitare în Java
- Top 11 caracteristici și avantaje ale C ++