Classi astratti C ++

“Una classe nel linguaggio di programmazione C ++ è considerata astratta se contiene almeno un singolo metodo virtuale. Il metodo virtuale può essere definito dalle classi che ereditano la classe astratta; Altrimenti, la sottoclasse sarebbe diventata una classe astratta. Le classi astratte sono state utilizzate per costruire le API C ++; Tuttavia, l'astrazione dei dati, che sarà l'idea di mantenere le impostazioni di configurazione a parte i dati associati, potrebbe non essere miscelato con metodi astratti. Una classe astratta opera come una classe di base da cui possono derivare alcune classi. Vediamo i diversi esempi di una classe astratta."

Esempio n. 1

La classe astratta "S" e i suoi membri sono costruiti nel seguente esempio:

#includere
Utilizzo dello spazio dei nomi std;
Classe s
pubblico:
Virtual int area () = 0;
void setwidth (int a)
wid = a;

void setheight (int b)
hght = b;

protetto:
int wid;
int hght;
;
Rettangolo di classe: public s
pubblico:
int area ()
return (wid * hght);

;
Triangolo di classe: pubblico S
pubblico:
int area ()
return (wid * hght)/2;

;
int main ()
Rettangolo Rec;
Triangolo tri;
Rec.setwidth (15);
Rec.Setheight (50);
Tri.setwidth (70);
Tri.Setheight (88);
cout << "The calculated area of the required rectangle: " << Rec.Area() << endl;
cout << "The calculated area of the required triangle: " << Tri.Area() << endl;

All'inizio del programma, includeremo la libreria richiesta . Quindi abbiamo usato lo spazio dei nomi standard come std. Ora imposteremo la classe chiamata "S". Dichiariamo pubblicamente un metodo virtuale. La funzione virtuale che abbiamo usato qui è area (). Quindi impiegheremo la funzione setWidth (). La larghezza della forma può essere specificata usando questa funzione. Il valore della larghezza è memorizzato in una variabile "A".

Ora specificheremo il valore dell'altezza della forma, quindi abbiamo usato la funzione Setheight (). Inizializziamo una variabile "b" per archiviare l'altezza della forma. Impostiamo i valori di larghezza e altezza come protetto. Il tipo di dati di larghezza e altezza sarà un numero intero. Nella riga successiva, erediteremo una forma rettangolo di classe dalla classe "S". Qui, troviamo l'area del rettangolo, quindi il metodo dell'area () verrà applicata. Restituisce l'area di un rettangolo moltiplicando il valore della larghezza per il valore del rettangolo.

Dopo tutto ciò, erediteremo un'altra forma, "Triangolo", dalla classe "S". Ora applichiamo le formule per ottenere l'area del triangolo. La funzione Area () viene chiamata. Questo restituisce il valore risultante. Otteniamo l'area di un triangolo moltiplicando la larghezza per altezza e quindi dividendo il valore per 2. Inoltre, chiameremo la funzione principale (). Definiamo gli oggetti di entrambe le classi, rettangoli e triangoli, rispettivamente.

Ora dobbiamo impostare i valori della larghezza e dell'altezza del rettangolo e del triangolo usando i metodi setwidth () e setRectle () di conseguenza. Alla fine, abbiamo impiegato l'istruzione "Cout" per visualizzare l'area calcolata del rettangolo e del triangolo.

Esempio n. 2

Le classi che ereditano da una classe astratta forniscono alcuni metodi virtuali. Eseguiremo l'istanza in cui ereditiamo le classi della classe astratta:

#includere
Utilizzo dello spazio dei nomi std;
base di classe

int n;
pubblico:
Virtual void f () = 0;
int otA () return n;
;
Classe derivata: base pubblica

int m;
pubblico:
void f () cout << "f() is being called";
;
int main (vuoto)

Derivato x;
X.F();
restituzione 0;

Innanzitutto, abbiamo integrato il file di intestazione . Insieme a questo, useremo lo spazio dei nomi standard come std. Quindi definiamo la classe definita "base". All'interno di questa classe, inizializziamo una variabile "N" e il tipo di dati di questa variabile verrà impostato come intero. Qui chiamiamo la funzione di questa classe e impostiamo queste funzioni come pubbliche. Abbiamo chiamato il metodo void f () della classe "base". Quindi utilizziamo anche la funzione get ().

Inoltre, erediteremo la classe derivata dalla classe genitore. Di conseguenza, ne deriviamo la classe di base. All'interno della classe derivata, dichiareremo una variabile "M". Ora chiamiamo pubblicamente la funzione void f (). All'interno di questa funzione, l'istruzione "Cout" sarà utilizzata per mostrare la linea sullo schermo. Iniziamo il codice nel corpo della funzione principale (). Per fare ciò, dobbiamo prima chiamare la funzione principale (). Chiamiamo la funzione f () associata alla classe derivata. Abbiamo applicato il comando "return 0" alla fine del codice.

Esempio n. 3

I costruttori possono essere presenti in una classe astratta. Creeremo il costruttore nell'illustrazione successiva:

#includere
Utilizzo dello spazio dei nomi std;
Classe B

protetto:
int u;
pubblico:
Virtual void f () = 0;
Base (int m)
u = m;
cout<<"Calling the base constructor\n";

;
Classe derivata: pubblico B

in tv;
pubblico:
Derivato (int m, int n): b (m) v = n;
void f () cout << "u = " << u << ", v = " << vrestituzione 0;

Qui abbiamo incluso il modulo . Quindi includiamo lo spazio dei nomi standard come std. Costruiremo la classe di base con il costruttore. Qui la classe di base funge da classe astratta. Inizializzamo la variabile "U" e la imposteremo per essere protetta. Innanzitutto, abbiamo chiamato la funzione void f (). Inoltre, chiameremo la funzione base (). Questa funzione contiene una variabile come argomento. Abbiamo usato l'istruzione "cout" all'interno di questa funzione. Erediteremo la classe derivata dalla classe "base" nel passaggio seguente. All'interno della classe derivata, inizializzeremo una variabile "V".

Ora chiamiamo pubblicamente la funzione derivata (). Passiamo due variabili come parametri. Chiamiamo la funzione B (). Quindi il vuoto f () viene chiamato. All'interno di questa funzione, l'istruzione "cout" sarà applicata per mostrare i valori. Dobbiamo invocare la funzione principale (). Qui, costruiamo l'oggetto di classe derivata. Questa funzione contiene due valori come attributo. Chiamiamo la funzione f () associata alla classe derivata. Immetteremo il comando "return 0" per terminare il programma.

Conclusione

Abbiamo attraversato la classe astratta in C ++ in questo tutorial. Gli oggetti di classe astratti sono difficili da creare. In C ++, un metodo astratto è un metodo virtuale che potrebbe avere una definizione. Tuttavia, la classe derivata sovrascriverebbe il metodo astratto per impedire alla classe derivata di diventare anche una classe astratta. L'allocazione di 0 durante la dichiarazione crea un metodo virtuale.