Introduzione alla classe astratta in C ++

Una classe è un tipo di dati definito dall'utente e ha i propri membri e funzioni di dati. I membri e le funzioni possono essere utilizzati creando un oggetto o un'istanza di quella classe. La memoria viene allocata per una classe solo quando viene creato un oggetto.

Quando vogliamo derivare alcuni comportamenti o caratteristiche da una classe all'altra, usiamo il concetto di eredità. Questo è il metodo per ereditare poche proprietà dalla classe genitore (classe base) alla classe figlio (classe derivata).

Nell'implementazione e nell'ereditarietà della classe, quando vogliamo definire le stesse funzioni sia nella classe base che derivata, usiamo la parola chiave "virtuale" insieme alla funzione della classe base. Questa funzione 'virtuale' specifica che la stessa funzione viene ridefinita o sovrascritta nella classe derivata.

Una classe astratta è una classe con pura funzione virtuale. Ora, cos'è una pura funzione virtuale? Una funzione virtuale pura è una funzione virtuale che non ha un corpo e viene assegnata come 0. Questo tipo di funzione viene implementata quando abbiamo bisogno di una funzione ma al momento non sappiamo quale sia la sua funzione. Questa funzione deve essere implementata o definita nella classe derivata. In caso contrario, anche la classe derivata diventa una classe astratta.

Una funzione virtuale pura è definita come segue:

virtual void func () = 0;

Esempio di classe astratta in C ++

Qui, discutiamo Esempio di classe astratta in C ++ con dettagli:

#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();
)

Produzione:

Qui Sample_Class è la classe base e Derived_Class è derivato da Sample_Class. Una funzione virtuale pura chiamata sample_func () è dichiarata nella classe base. È assegnato a 0, il che significa che non ha nessuno e nulla è implementato all'interno della funzione. Pertanto, la classe base è diventata una classe astratta in quanto ha una funzione virtuale pura. Inizialmente, quando Derived_Class deriva dalla classe base, diventa anche una classe astratta. Ma nella classe derivata, viene definita la classe sample_func (), che impedisce alla classe derivata di diventare una classe astratta. Quando viene creato l'oggetto della classe derivata e viene chiamata la funzione, verrà stampato l'output come "la funzione virtuale pura è implementata".

Non è possibile creare un'istanza di una classe astratta, il che significa che non è possibile creare un'istanza o un oggetto per una classe astratta. L'oggetto non può essere creato perché la classe non è implementata completamente. In realtà è una base per una classe che sarà implementata completamente in seguito. Ma i puntatori o i riferimenti possono essere creati per una classe astratta. Questo puntatore può essere utilizzato per chiamare le funzioni di classe derivate. Una classe astratta può avere altri membri di dati e funzioni simili all'implementazione della classe normale insieme a una funzione virtuale pura.

Il punto precedente può essere spiegato attraverso il programma seguente

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();
)

Produzione:

Qui avremo un errore poiché non è possibile creare un oggetto per la classe astratta.

Al contrario, è possibile implementare la seconda e la terza riga di codice, è possibile creare un puntatore che può essere utilizzato per chiamare la funzione di classe derivata.

Qui, nella funzione sopra Class1 è la classe base e poiché ha una funzione virtuale pura (func1) è diventata una classe astratta. Class2 deriva dalla classe padre Class1. Il func1 è definito nella classe derivata. Nella funzione principale, quando proviamo a creare un oggetto di tipo classe base avremo un errore, poiché gli oggetti non possono essere creati per la classe astratta. Considerando che quando proviamo a creare un puntatore del tipo di classe base, verrà creato correttamente e possiamo puntarlo alla classe derivata. Questo puntatore può essere utilizzato per chiamare la funzione di classe derivata.

Una classe astratta può avere un costruttore simile alla normale implementazione della classe. Nel caso del distruttore, possiamo dichiarare un puro distruttore virtuale. È importante disporre di un distruttore per eliminare la memoria allocata per la classe. Il distruttore virtuale puro è un distruttore assegnato a 0 ma deve essere definito dalla stessa classe, poiché il distruttore non viene di solito ignorato.

Esempio di implementazione di costruttore e distruttore per la classe astratta in C ++

Qui, discutiamo Esempio di classe astratta in C ++ con dettagli:

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;
)

Uscita :

Qui, nell'esempio sopra, la classe Base è una classe astratta con pura funzione virtuale func1 (), un costruttore e un puro distruttore virtuale. La pura funzione virtuale è definita nella classe derivata impedendo così alla classe derivata di diventare una classe astratta. Il puro distruttore virtuale è definito dalla classe Base esterna alla classe. Se vogliamo definire la funzione membro di una classe esterna alla classe, è necessario utilizzare l'operatore di risoluzione dell'ambito come mostrato nell'esempio. Viene creato un puntatore del tipo di classe base e puntato sulla classe derivata. Quando il distruttore viene chiamato usando 'delete', prima viene chiamato il distruttore di classe derivato e poi il distruttore di classe base.

Conclusione

Quindi, per compilare tutto su una classe astratta, possiamo dire che la classe astratta è una classe con una pura funzione virtuale. Questa pura funzione virtuale deve essere definita nella classe derivata, altrimenti la classe derivata diventa anche una classe astratta. L'oggetto non può essere creato per la classe astratta, ma è possibile creare un puntatore che può essere puntato sulla classe derivata.

Articoli consigliati

Questa è una guida alla classe astratta in C ++. Qui discutiamo dell'introduzione alla classe astratta e dell'implementazione di costruttore e distruttore in C ++ insieme al suo esempio. Puoi anche consultare i seguenti articoli per saperne di più-

  1. Classe astratta in Python
  2. Classe astratta in Java
  3. Costruttore e distruttore in C ++
  4. Sostituzione in C ++
  5. Sostituzione in Java
  6. Principali 11 caratteristiche e vantaggi di C ++

Categoria: