Primordial vs Virtuel

C'est la question classique de la façon dont le polymorphisme fonctionne, je pense. L'idée principale est que vous voulez résumé le type spécifique de chacun des objets. En d'autres termes: Vous voulez être en mesure d'appeler l'Enfant des cas, sans savoir qu'il est un enfant!

Voici un exemple:
En supposant que vous avez la classe "Enfant" et de classe "Enfant2" et "Enfant3" vous voulez être en mesure de se référer à eux par le biais de leur classe de base (le Parent).

Parent* parents[3];
parents[0] = new Child();
parents[1] = new Child2();
parents[2] = new Child3();

for (int i=0; i<3; ++i)
    parents[i]->say();

Comme vous pouvez l'imaginer, c'est très puissant. Il vous permet d'étendre le Parent autant de fois que vous le souhaitez et des fonctions qui prennent un Parent pointeur fonctionne toujours. Pour que cela fonctionne, comme d'autres parlent de vous avez besoin de déclarer la méthode virtuelle.

Essayer avec:

Parent *a = new Child();
Parent *b = new Parent();

a->say();
b->say();

Sans virtual, à la fois avec l'impression '1'. Ajouter virtuel, et l'enfant va agir comme un Enfant, même s'il est visé par l'intermédiaire d'un pointeur vers un Parent.

Bien je l'ai testé moi-même, parce qu'il y a beaucoup de choses que nous pouvons penser:

#include <iostream>
using namespace std;
class A
{
public:
    virtual void v() { cout << "A virtual" << endl; }
    void f() { cout << "A plain" << endl; }
};

class B : public A
{
public:
    virtual void v() { cout << "B virtual" << endl; }
    void f() { cout << "B plain" << endl; }
};

class C : public B
{
public:
    virtual void v() { cout << "C virtual" << endl; }
    void f() { cout << "C plain" << endl; }
};

int main()
{
    A * a = new C;
    a->f();
    a->v();

    ((B*)a)->f();
    ((B*)a)->v();
}

de sortie:

A plain
C virtual
B plain
C virtual

Je pense que une bonne, simple et bref, la réponse pourrait ressembler à ça (parce que je pense que les gens qui peuvent comprendre plus peut mémoriser moins donc besoin pour faire court et simple explication):

Méthodes virtuelles vérifie les DONNÉES de l'instance sur laquelle pointe le pointeur, alors que les méthodes classiques ne sont pas ainsi, l'appel de la méthode procès correspondant au type spécifié.

Le point de cette fonction est la suivante: supposons que vous disposez d'un tableau de de. Le tableau peut contenir de B, de C, (ou même les types dérivés.). si vous souhaitez de manière séquentielle appel à la même méthode de tous les cas, vous devez appeler chacun vous surchargé.

Je trouve cela assez difficile à comprendre, et évidemment toute C++ cours devrait expliqué comment cela est réalisé, car la plupart du temps vous êtes simplement appris à propos des fonctions virtuelles, vous les utilisez, mais jusqu'à ce que vous comprenez comment le compilateur de les comprendre et comment l'exécutable sera de gérer les appels, vous êtes dans l'obscurité.

La chose à propos de VFtables est que je n'ai jamais été expliqué quel genre de code, il ajoute, et c'est évidemment là où C++ nécessite beaucoup plus d'expérience que C, et ce pourrait être la raison principale de C++ a été étiqueté comme "lent" dans ses premiers jours: en fait, c'est puissant, mais comme tout, il est puissant, si vous savez comment l'utiliser, ou bien vous venez de "coup l'ensemble de votre jambe off".

C'est un aspect très important de la programmation en c++-- presque à chaque interview que j'ai été, je me pose cette question.

Qu'advient-il si vous changez vos principales de:

int main() { Parent* a = new Child(); a->say(); return 0; }

Aussi, il vaut la peine de comprendre ce qu'est une vtable est.