Pourquoi utiliser de la classe de base des pointeurs pour les classes dérivées

La puissance de polymorphisme n'est pas vraiment évident dans votre exemple simple, mais si vous étendre un peu, il pourrait devenir plus claire.

class vehicle{
      .....
      virtual int getEmission();
 }

 class car : public vehicle{
      int getEmission();
 }

 class bus : public vehicle{
      int getEmission();
 }

 int main()
 {
      car a;
      car b;
      car c;
      bus d;
      bus e;

      vehicle *traffic[]={&a,&b,&c,&d,&e};

      int totalEmission=0;

      for(int i=0;i<5;i++)
      {
          totalEmission+=traffic[i]->getEmission();
      }

 }

Cela vous permet d'itérer sur une liste de pointeurs et des méthodes différentes pour obtenir appelée en fonction du type sous-jacent. Fondamentalement, il vous permet d'écrire du code où vous n'avez pas besoin de savoir ce que l'enfant est de type au moment de la compilation, mais le code exercer le droit de la fonction, de toute façon.

son pour mettre en œuvre le polymorphisme. Sauf si vous avez de la classe de base pointeur
en pointant l'objet dérivé que vous ne peut pas avoir le polymorphisme ici.

L'une des principales caractéristiques des classes dérivées est qu'un pointeur vers une
dérivée de la classe est de type compatible avec un pointeur vers la classe de base.
Le polymorphisme est l'art de prendre avantage de cette simple mais
puissant et polyvalent fonctionnalité, qui apporte de l'Orienté Objet
Les méthodologies à son plein potentiel.

En C++, un type/sous-type de relation dans laquelle une base de
classe pointeur ou une référence de répondre à des de sa classe dérivée
sous-types sans programmeur d'intervention. Cette capacité à manipuler
plus d'un type avec un pointeur ou une référence à une classe de base est
parle de lui comme le polymorphisme.

Sous-type de polymorphisme permet d'écrire le noyau de notre application
indépendant des types nous souhaitons manipuler. Plutôt, nous
programme de l'interface publique de la classe de base de notre abstraction
par le biais de la classe de base des pointeurs et des références. Au moment de l'exécution, la
type référencé est résolu et l'instance appropriée de l'
interface publique est invoquée. Le moment de l'exécution de la résolution de l'
approprié de la fonction à appeler est qualifié de liaison dynamique (par défaut,
les fonctions sont résolu statiquement à la compilation). En C++, dynamique
la liaison est prise en charge par un mécanisme appelé de la classe virtuelle
fonctions. Sous-type de polymorphisme à travers l'héritage et dynamique
la liaison de fournir la base pour la programmation orientée objet -

Le principal avantage d'une hiérarchie d'héritage, c'est que nous pouvons le programme
l'interface publique de la classe de base abstraite plutôt que de la
les différents types qui forment sa hiérarchie d'héritage, de cette façon
blindage de notre code de changements dans la hiérarchie. Nous définissons la fonction eval(),
par exemple, comme un public virtuel de la fonction de l'abrégé de Requête de la base de
classe. Par l'écriture de code comme
_rop->eval();
le code de l'utilisateur est à l'abri de la variété et de la volatilité de notre langage de requête. Cela permet non seulement par l'ajout, à la révision,
ou la suppression de types sans avoir besoin de modifier les programmes de l'utilisateur, mais
libère le fournisseur d'un nouveau type de requête d'avoir à recoder le comportement
ou des actions communes à tous les types dans la hiérarchie elle-même. C'est
pris en charge par deux caractéristiques particulières de l'héritage: le polymorphisme
et de liaison dynamique. Lorsque l'on parle de polymorphisme en C++, nous
principalement signifie la capacité d'un pointeur ou une référence d'une classe de base
à l'adresse de l'une de ses classes dérivées. Par exemple, si nous définissons un
non-membre de la fonction eval (), comme suit, //pquery peut répondre à toute de la
les classes dérivées à partir d'une Requête
void eval( const Query *pquery ) { pquery->eval(); }
nous pouvons l'appeler légalement, en passant l'adresse d'un objet de l'une des
quatre types de requêtes:

    int main() 
{ 
AndQuery aq;
 NotQuery notq; 
OrQuery *oq = new OrQuery; 
NameQuery nq( "Botticelli" ); //ok: each is derived from Query 
//compiler converts to base class automatically 
eval( &aq );
 eval( &notq ); 
eval( oq ); 
eval( &nq );
 } 

alors qu'une tentative d'invoquer la fonction eval() avec l'adresse d'un objet n'est pas dérivée à partir d'une Requête
résultats dans une erreur de compilation:

int main()
 { string name("Scooby-Doo" ); //error: string is not derived from Query 
eval( &name); 
}

Au sein de la fonction eval(), l'exécution de pquery->eval(); doit invoquer la
approprié eval() fonction membre virtuelle basée sur la classe réelle
objet pquery adresses. Dans l'exemple précédent, pquery à son tour
les adresses un AndQuery objet, un NotQuery objet, un OrQuery objet,
et un NameQuery objet. À chaque invocation moment pendant l'exécution
de notre programme, le type de classe adressée par pquery est
déterminé, et le cas échéant la fonction eval() de l'instance est appelée. Dynamique
la reliure est le mécanisme par lequel cela se produit.
Dans le paradigme orienté objet, le programmeur manipule un inconnu instance d'un lié, mais la multitude infinie de types. (L'ensemble de
types est lié par sa hiérarchie d'héritage. En théorie, cependant, il
pas de limite à la profondeur et l'étendue de la hiérarchie.) En C++ c'
est réalisé grâce à la manipulation des objets par le biais de la classe de base
les pointeurs et références seulement. Dans l'objet à base de paradigme, l'
programmeur
manipule une instance d'un fixe, singulier type qui est complètement défini au moment de la compilation. Bien que l'
polymorphe de la manipulation d'un objet nécessite que l'objet
accessible soit par l'intermédiaire d'un pointeur ou d'une référence, de la manipulation des
un pointeur ou d'une référence en C++ ne prend pas nécessairement en elle-même résultat
dans le polymorphisme. Par exemple, considérons

//no polymorphism 
  int *pi; 
//no language-supported polymorphism 
  void *pvi; 
//ok: pquery may address any Query derivation
  Query *pquery;

En C++, le polymorphisme
existe uniquement à l'intérieur de chacun des hiérarchies de classes. Les pointeurs de type
void* peut être décrit comme polymorphe, mais ils sont sans explicite
support de la langue — qui est, ils doivent être gérés par le programmeur
par le biais de conversions explicites et une certaine forme de discriminant qui permet de suivre
le type réel d'être résolus.