Voilà un petit exemple de programmation orienté objet, qui met en jeu des fonctions virtuelles pures (donc une classe de base abstraite), tiré d´un bouquin :

Class VCR {
public :
virtual void on() =0;
virtual void off() =0;
virtual void record() =0;
virtual void stop() =0;
virtual void play() =0;
};

Class Panasonic : public VCR {
public :
void on();
void off();
void record();
void stop();
void play();
};

Class Sony : public VCR {
public :
void on();
void off();
void record();
void stop();
void play();
};

En fait je vois pas l´utilité, des fonctions virtuelles pures, ....
Elles ne seraient pas déclarées, ça changerait rien, puisque leurs implémentations sont propres aux sous-classes.

A quoi ce procéder sert réellement ?
Organiser d´avantage le code, séparer l´interface, de l´implémentation ? Menfin, son utilité ne m´apparait pas encore évidente ....

Pourriez-vous méclairer ??
Merci d´avance

l´utilité est de pouvoir écrire une fonction du type :

void programmer_emission(int heure,VCR magnetoscope)
{
while(GetTime()<heure);
magnetoscope.on();
magnetoscope.record();
}

tu peut l´utiliser comme celà :
Sony hyper_vcr;
Panasonic vcr_ultra;
programmer_emission(12,hyper_vcr);
programmer_emission(12,vcr_ultra);

C´est à dire que ta classe VCR est ce qu´on appelle une interface : tu peut faire hériter des classes de cette classe là qui pourront implémenteront obligatoirement certaines fonctionnalité de bases communes à tout les VCR (le =0 dans les déclarations oblige les classe enfant a déclarer les même fonctions, mais rien n´empêche un Sony d´avoir d´autre fonction en plus) ce qui fait que tu peut écrire des fonctions qui marcheront pour tout les VCR en utilisant la classe VCR. Et le sbonnes fonctions seront appellé car c´est le principe des fonctions virtuelle.

Je n´ais pas l´impression d´avoir été clair. Donc n´hésite pas à demander plus de précision.

ce que je veux dire, c´est que sans la classe VCR, tu ne pourraispas écrire la fonction programmer_emission, il faudra que tu ne fasse une pour les magnétoscope Sony, et une pour les Panasonic et une pour chaque marque que tu rajoutterais.

Si si ta réponse était claire, et c´est ce que j´attendais .... Jy vois plus clair

Mais, fondalementalement, les déclarations de fonctions virtuelles pures, telque virtual void record() =0; ne servent à rien.

virtual void record() =0; ne serait pas déclarée, on pourrait tout de même implémenter une fonction void record(); dans chaque sous-classe héritant de VCR.

Les seules utilités que jy vois, c´est que ça permet une compréension claire du code (le client, ne verra pas les sous-classes héritant de VCR, mais sera néanmoins quelles fonctions importantes y seront implémantées). Ca oblige aussi le programmeur à integrer une fonction void record(); dans la sous-classse héritant de VCR.
Mais cd dernier point ce traduit comment ?
-> Cela génère-t-il une erreur à la compilation, disant que telle fonction n´a pas été déclarée, alors qu´elle est définit comme étant une fonction virtuelle pure, dans la classe mère ?

Perso lorsque je code ce genre de class, c´est surtout car elles ne me sont pas reellement utile en tant qu´objet a traité (je sais pas si tu vois ce que je veux dire). Mais elles me servent uniquement de "moule" pour pouvoir definir les class filles.

Ca me permet de disposer d´une hierarchie claire et precise

j´ai pas trop compris ta question, mais dapres ce que je comprend, tu dois y mettre ta procedure (sans etre obligé de la definir) dans la fonction fille (mais les consequences seront que si la fonction n´est pas definie ta class sera abstraite, tout comme la class mere)

"je sais pas si tu vois ce que je veux dire" -> c´était exactement cela que je voulais savoir ....

Et pour la deuxième réponse de même ...
Merchi biench

"virtual void record() =0; ne serait pas déclarée, on pourrait tout de même implémenter une fonction void record(); dans chaque sous-classe héritant de VCR"

oui, mais tu perds tout l´interet de l´heritage. Ici, tu exposes une interface haut niveau qui effectue du code specialise de maniere transparente.
d´un point de vue externe, on te file un VCR *, que ce soit un panasonic ou un sony, tu t´en fiches, tu appelles une methode dessus et le code correspondant sera execute.
C´est la base meme du polymorphisme.

a noter que :
- avoir une interface virtuelle permet d´empecher l´instanciation.
- on peut avoir du code virtuel pur, uniquement appelable depuis les classes derivees donc. Ca permet de factorise des algos sur des concepts tres abstraits

déclarer void record()=0 dans VCR est très important : ça oblige toute les classes qui héritent de VCR a déclarer aussi cete fonction (sinon on pourrait le faire, mais on ne serait pas obligé).

Et donc tu peut utiliser la fonction record dans une fonction utilisant la clase VCR (come dans mon exemple). Sinon tu ne pourrais pas utiliser record pour un objet VCR puice que record ne serait pas membre de la classe VCR.