A volte l'implementazione di tutte le funzioni non può essere fornita in una classe base perché non conosciamo l'implementazione. Tale classe è chiamata an classe astratta .Ad esempio, lascia che Shape sia una classe base. Non possiamo fornire l'implementazione della funzione draw() in Shape, ma sappiamo che ogni classe derivata deve avere un'implementazione di draw(). Allo stesso modo, una classe Animale non ha l’implementazione di move() (assumendo che tutti gli animali si muovano), ma tutti gli animali devono sapere come muoversi. Non possiamo creare oggetti di classi astratte.
UN pura funzione virtuale (o funzione astratta) in C++ è una funzione virtuale per la quale possiamo avere un'implementazione, ma dobbiamo sovrascrivere quella funzione nella classe derivata, altrimenti anche la classe derivata diventerà una classe astratta. Una funzione virtuale pura viene dichiarata assegnando 0 nella dichiarazione.
Esempio di funzioni virtuali pure
C++
// An abstract class> class> Test {> >// Data members of class> public>:> >// Pure Virtual Function> >virtual> void> show() = 0;> >/* Other members */> };> |
>
>
mylivericket
Esempio completo
Una funzione virtuale pura viene implementata da classi derivate da una classe Abstract.
C++
// C++ Program to illustrate the abstract class and virtual> // functions> #include> using> namespace> std;> class> Base {> >// private member variable> >int> x;> public>:> >// pure virtual function> >virtual> void> fun() = 0;> >// getter function to access x> >int> getX() {>return> x; }> };> // This class inherits from Base and implements fun()> class> Derived :>public> Base {> >// private member variable> >int> y;> public>:> >// implementation of the pure virtual function> >void> fun() { cout <<>'fun() called'>; }> };> int> main(>void>)> {> >// creating an object of Derived class> >Derived d;> >// calling the fun() function of Derived class> >d.fun();> >return> 0;> }> |
>
urfi javed
>Produzione
fun() called>
Alcuni fatti interessanti
1. Una classe è astratta se ha almeno una funzione virtuale pura.
Esempio
Nel codice C++ seguente, Test è una classe astratta perché ha una funzione virtuale pura show().
C++
// C++ program to illustrate the abstract class with pure> // virtual functions> #include> using> namespace> std;> class> Test {> >// private member variable> >int> x;> public>:> >// pure virtual function> >virtual> void> show() = 0;> >// getter function to access x> >int> getX() {>return> x; }> };> int> main(>void>)> {> >// Error: Cannot instantiate an abstract class> >Test t;> >return> 0;> }> |
>
>
Produzione
Compiler Error: cannot declare variable 't' to be of abstract type 'Test' because the following virtual functions are pure within 'Test': note: virtual void Test::show()>
2. Possiamo avere puntatori e riferimenti di tipo di classe astratta.
Ad esempio, il seguente programma funziona correttamente.
C++
// C++ program that demonstrate that> // we can have pointers and references> // of abstract class type.> #include> using> namespace> std;> class> Base {> public>:> >// pure virtual function> >virtual> void> show() = 0;> };> class> Derived :>public> Base {> public>:> >// implementation of the pure virtual function> >void> show() { cout <<>'In Derived
'>; }> };> int> main(>void>)> {> >// creating a pointer of type> >// Base pointing to an object> >// of type Derived> >Base* bp =>new> Derived();> >// calling the show() function using the> >// pointer> >bp->mostra();> >return> 0;> }> |
zeri intorpiditi
>
>Produzione
In Derived>
3. Se non sovrascriviamo la pura funzione virtuale nella classe derivata, anche la classe derivata diventa una classe astratta.
L'esempio seguente dimostra lo stesso.
C++
abc con numeri
// C++ program to demonstrate that if we do not override> // the pure virtual function in the derived class, then> // the derived class also becomes an abstract class> #include> using> namespace> std;> class> Base {> public>:> >// pure virtual function> >virtual> void> show() = 0;> };> class> Derived :>public> Base {> };> int> main(>void>)> {> >// creating an object of Derived class> >Derived d;> >return> 0;> }> |
>
>
Produzione
Compiler Error: cannot declare variable 'd' to be of abstract type 'Derived' because the following virtual functions are pure within 'Derived': virtual void Base::show()>
4. Una classe astratta può avere costruttori.
Ad esempio, il seguente programma viene compilato e funziona correttamente.
C++
// C++ program to demonstrate that> // an abstract class can have constructors.> #include> using> namespace> std;> // An abstract class with constructor> class> Base {> protected>:> >// protected member variable> >int> x;> public>:> >// pure virtual function> >virtual> void> fun() = 0;> >// constructor of Base class> >Base(>int> i)> >{> >x = i;> >cout <<>'Constructor of base called
'>;> >}> };> class> Derived :>public> Base {> >// private member variable> >int> y;> public>:> >// calling the constructor of Base class> >Derived(>int> i,>int> j)> >: Base(i)> >{> >y = j;> >}> >// implementation of pure virtual function> >void> fun()> >{> >cout <<>'x = '> << x <<>', y = '> << y <<>'
'>;> >}> };> int> main(>void>)> {> >// creating an object of Derived class> >Derived d(4, 5);> >// calling the fun() function of Derived class> >d.fun();> >// creating an object of Derived class using> >// a pointer of the Base class> >Base* ptr =>new> Derived(6, 7);> >// calling the fun() function using the> >// pointer> >ptr->divertimento();> >return> 0;> }> |
>
>Produzione
Constructor of base called x = 4, y = 5 Constructor of base called x = 6, y = 7>
5. Una classe astratta in C++ può anche essere definita utilizzando la parola chiave struct.
Esempio
Numeri primi di programmazione Java
struct shapeClass { virtual void Draw()=0; }> Confronto con Java
In Java, una classe può essere resa astratta utilizzando una parola chiave astratta. Allo stesso modo, una funzione può essere resa puramente virtuale o astratta utilizzando una parola chiave astratta. Vedere Classi astratte in Java per ulteriori dettagli.
Interfaccia e classi astratte
Un'interfaccia non ha un'implementazione di nessuno dei suoi metodi, può essere considerata come una raccolta di dichiarazioni di metodi. In C++, un'interfaccia può essere simulata rendendo tutti i metodi puramente virtuali. In Java esiste una parola chiave separata per l'interfaccia.
Possiamo pensare all'interfaccia come a file header in C++, poiché nei file header forniamo solo il corpo della classe che lo implementerà. Allo stesso modo in Java in Interface forniamo solo il corpo della classe e scriviamo il codice vero e proprio in qualunque classe lo implementi.