§19. Clase abstracte
Un tip de funcţii virtuale speciale sunt funcţiile virtuale abstracte. Prototipurile acestor funcţii se deosebesc de prototipurile funcţiilor ne-abstracte prin faptul că se termină cu ”=0”:
virtual tipr nume_fv(lista_pf)=0; // functie abstracta
Funcţiile abstracte pot fi doar parte componentă a unor clase. Clasele care conţin măcar o funcţie abstractă se numesc clase abstracte. Pot exista clase abstracte care conţin doar funcţii abstracte. Caracteristica principală a funcţiilor abstracte constă în faptul că ele nu sunt realizate în clasa lor de declarare. Deci, clasa conţine doar descrierea prototipului funcţiei, fără a fi definit şi corpul funcţiei. Astfel de funcţii se utilizează atunci, când clasă este una foarte abstractă şi la nivelul dat de abstractizare este imposibil de a defini algoritmic funcţia. Ca rezultat al existenţei în clasa abstractă a funcţiilor nedefinite este interzis de a crea obiecte în baza unei clase abstracte. O clasă abstractă poate fi folosită doar ca clasă de bază în procesul de moştenire. Deci în procesul de generare a unei clase derivate una sau mai multe clase de bază pot fi şi clase abstracte. Dacă în clasa derivată obţinută sunt definite toate funcţiile abstracte moştenite din clasele de bază, atunci obţinem o clasă obişnuită în baza căreia putem crea obiecte. Dacă însă în clasa derivată obţinută rămâne nedefinită măcar o funcţie abstractă, atunci clasă derivată va fi în continuare una abstractă. Pot exista situaţii când în procesul de moştenire sunt implicate doar clase abstracte. Deci, clasele abstracte sunt utilizate ca o interfaţă comună pentru derivarea diferitelor clase, care au o legătură cu ea.
Exemplu. De alcătuit un program în care este realizată clasa abstractă figura din care sunt derivate clasele cerc şi patrat. Unele operaţii cu obiectele de tip cerc şi patrat sunt efectuate în bază de polimorfism. La descrierea claselor cerc şi patrat este utilizată clasa ajutătoare punct.
class punct
{
int x;
int y;
public:
punct(int x1=0, int y1=0)
{ x=x1; y=y1; }
punct(punct & p)
{ x=p.x; y=p.y; }
int getx() {return x;}
int gety() {return y;}
};
//----------
class figura
{
public :
virtual void afisare()=0;
virtual void miscare(punct p)=0;
};
//----------
class cerc: public figura
{
punct centru;
int raza;
public:
cerc(punct c, int r) : centru(c)
{ raza=r; }
void afisare();
void miscare(punct p);
};
//----------
class patrat : public figura
{
punct virf ;
int lat;
public:
patrat(punct v, int l) : virf(v)
{ lat=l; }
void afisare();
void miscare(punct p);
};
//----------
void cerc :: afisare()
{
circle(centru.getx(), centru.gety(), raza);
}
//----------
void cerc :: miscare(punct p)
{
int c=getcolor() ;
setcolor(getbkcolor());
afisare();
centru=p;
setcolor(c);
afisare();
}
//----------
void patrat :: afisare()
{
int x=virf.getx();
int y=virf.gety();
line(x, y, x+lat, y);
line(x, y, x, y+lat);
line(x+lat, y, x+lat, y+lat);
line(x, y+lat, x+lat, y+lat);
}
//----------
void patrat :: miscare(punct p)
{
int c=getcolor();
setcolor(getbkcolor());
afisare();
virf=p;
setcolor(c);
afisare();
}
Implementarea claselor este memorată în fişierul cerc_pat.hpp, iar programul principal este memorat în fişierul cerc_pat.cpp, conţinutul căruia urmează.
#include <iostream.h>
#include <conio.h>
#include <graphics.h>
#include ”cerc_pat.hpp”
void main()
{
int rg=DETECT, srg, er;
figura *pf;
initgraph(&rg, &srg, "");
er=graphresult();
if(er==grOk)
{
punct pc(100,100), pv(10,17);
cerc c1(pc, 20);
patrat p(pv, 200);
pf = &c1;
pf->afisare();
pf = &p;
pf->afisare();
pf->miscare(pc);
getch();
closegraph();
}
}