Muss lernen! Grundbedingungen für die Implementierung polymorpher Mechanismen in C++-C#.Net-Tutorial-php.cn

So implementieren Sie den polymorphen Mechanismus von C++. Der Mechanismus zum Implementieren des laufenden Polymorphismus besteht darin, das virtuelle Schlüsselwort vor der Funktion der Basisklasse hinzuzufügen, die Funktion in der abgeleiteten Klasse neu zu schreiben und sie entsprechend dem tatsächlichen Typ aufzurufen des Objekts zur Laufzeit.

Die Implementierung und das Prinzip des C++-Polymorphismus

Der Polymorphismus von C++ lässt sich in einem Satz zusammenfassen: Fügen Sie das virtuelle Schlüsselwort vor der Funktion der Basisklasse hinzu und fügen Sie hinzu das virtuelle Schlüsselwort vor der abgeleiteten Funktion. Wenn diese Funktion in der Klasse überschrieben wird, wird die entsprechende Funktion zur Laufzeit entsprechend dem tatsächlichen Typ des Objekts aufgerufen. Wenn der Objekttyp eine abgeleitete Klasse ist, rufen Sie die Funktion der abgeleiteten Klasse auf. Wenn der Objekttyp eine Basisklasse ist, rufen Sie die Funktion der Basisklasse auf

1: Die mit der virtuellen deklarierte Funktion Das Schlüsselwort wird als virtuelle Funktion bezeichnet. Die virtuelle Funktion muss eine Mitgliedsfunktion der Klasse sein.

2: Klassen mit virtuellen Funktionen verfügen über eine eindimensionale virtuelle Funktionstabelle, die als virtuelle Tabelle bezeichnet wird. Das Objekt der Klasse verfügt über einen virtuellen Zeiger, der auf den Anfang der virtuellen Tabelle zeigt. Die virtuelle Tabelle entspricht der Klasse und der virtuelle Tabellenzeiger entspricht dem Objekt.

3: Polymorphismus ist die mehrfache Implementierung einer Schnittstelle und ist der Kern der objektorientierten Methode. Er ist in Klassenpolymorphismus und Funktionspolymorphismus unterteilt.

4: Polymorphismus wird mit virtuellen Funktionen kombiniert, kombiniert mit dynamischer Bindung

5: Reine virtuelle Funktionen sind virtuelle Funktionen plus = 0;

6: Zusammenfassung Eine Klasse ist eine Klasse, die mindestens eine rein virtuelle Funktion enthält.

Reine virtuelle Funktion: virtual void fun()=0; das heißt, abstrakte Klasse! Diese Funktion muss in der Unterklasse implementiert werden, das heißt, es gibt zuerst einen Namen, keinen Inhalt und der Inhalt wird in der abgeleiteten Klasse implementiert.

Schauen wir uns zuerst ein Beispiel an

#include <iostream> #include <stdlib.h>using namespace std; 

class Father
{public:    void Face()
    {        cout << "Father&#39;s face" << endl;
    }    void Say()
    {        cout << "Father say hello" << endl;
    }
};class Son:public Father
{public:     
    void Say()
    {        cout << "Son say hello" << endl;
    }
};int main()
{
    Son son;
    Father *pFather=&son; // 隐式类型转换
    pFather->Say();    return 0;
}

Nach dem Login kopieren

Das Ausgabeergebnis ist:

Father say hello

Nach dem Login kopieren

In der main()-Funktion definieren wir zunächst ein Objekt son der Son-Klasse und Definieren Sie dann eine Zeigervariable pFather, die auf die Father-Klasse zeigt, und verwenden Sie diese Variable dann, um pFather->Say() aufzurufen. Es wird geschätzt, dass viele Leute dazu neigen, diese Situation mit dem Polymorphismus von C++ zu verwechseln, weil sie denken, dass son tatsächlich ein ist Objekt der Son-Klasse, und sollte Say of Son-Klasse aufrufen und „Son say hallo“ ausgeben, aber das Ergebnis ist nicht

Aus Kompilierungssicht:

Beim Kompilieren. Der C++-Compiler muss jeweils die Adresse der vom Objekt aufgerufenen Funktion (nicht virtuelle Funktion) ermitteln. Dies wird als frühe Bindung bezeichnet. Wenn wir die Adresse des Objektsohns der Son-Klasse zuweisen, führt der C++-Compiler eine Typkonvertierung durch Zu diesem Zeitpunkt berücksichtigt der C++-Compiler die Adresse des Father-Objekts. Wenn pFather->Say() in der Hauptfunktion ausgeführt wird, wird natürlich die Say-Funktion des Father aufgerufen Objekt

Aus Gedächtnisperspektive

Muss lernen! Grundbedingungen für die Implementierung polymorpher Mechanismen in C++

Das Speichermodell des Son-Klassenobjekts ist wie oben gezeigt

Wenn wir ein Objekt von Son konstruieren Klasse müssen wir zuerst den Konstruktor der Vaterklasse aufrufen, um das Objekt der Vaterklasse zu konstruieren, und dann den Konstruktor der Sohnklasse aufrufen. Die Funktion schließt die Konstruktion ihres eigenen Teils ab und fügt so ein vollständiges Objekt der Sohnklasse heraus. Wenn wir das Sohnklassenobjekt in den Vatertyp konvertieren, wird das Objekt als die obere Hälfte des gesamten Speichermodells des ursprünglichen Objekts betrachtet, bei dem es sich in der obigen Abbildung um den „vom Vaterobjekt belegten Speicher“ handelt Verwenden Sie die Typkonvertierung. Wenn der Objektzeiger seine Methode aufruft, ruft er natürlich die Methode im Speicher auf, in der er sich befindet. Daher ist es logisch, „Vater sag Hallo“ auszugeben.

Wie viele Leute denken, wissen wir, dass pFather tatsächlich auf ein Objekt der Son-Klasse verweist. Wir hoffen, dass das Ausgabeergebnis die Say-Methode der Son-Klasse ist Um dieses Ergebnis zu erreichen, müssen Sie virtuelle Funktionen verwenden.

Das vorherige Ausgabeergebnis ist darauf zurückzuführen, dass der Compiler beim Kompilieren bereits die Adresse der vom Objekt aufgerufenen Funktion ermittelt hat. Um dieses Problem zu lösen, muss der Compiler eine späte Bindung verwenden Der Typ des Objekts und die korrekte aufrufende Funktion zur Laufzeit müssen beim Deklarieren der Funktion in der Basisklasse vom Compiler verwendet werden. Wir nennen eine solche Funktion eine virtuelle Funktion Wenn die Funktion in der Basisklasse als virtuell deklariert wird, ist sie in allen abgeleiteten Klassen virtuell, ohne dass sie explizit als virtuell deklariert werden muss.

Ändern Sie den Code leicht und schauen Sie sich die laufenden Ergebnisse an

#include <iostream> #include <stdlib.h>using namespace std; 

class Father
{public:    void Face()
    {        cout << "Father&#39;s face" << endl;
    }    virtual void Say()
    {        cout << "Father say hello" << endl;
    }
};class Son:public Father
{public:     
    void Say()
    {        cout << "Son say hello" << endl;
    }
};int main()
{
    Son son;
    Father *pFather=&son; // 隐式类型转换
    pFather->Say();    return 0;
}

Nach dem Login kopieren

Die laufenden Ergebnisse:

Son say hello

Nach dem Login kopieren

Wir haben festgestellt, dass das Ergebnis „Sohn sagt Hallo“ ist, was bedeutet dass der richtige Aufruf basierend auf dem Typ des Objekts erfolgt und was dann hinter den Kulissen passiert, wenn wir Say() als virtuell deklarieren.

Beim Kompilieren stellt der Compiler fest, dass es in der Vaterklasse virtuelle Funktionen gibt. Zu diesem Zeitpunkt erstellt der Compiler eine virtuelle Tabelle (d. h. vtable) für jede Klasse, die virtuelle Funktionen enthält ein eindimensionales Array, speichern Sie die Adresse jeder virtuellen Funktion in diesem Array,

Muss lernen! Grundbedingungen für die Implementierung polymorpher Mechanismen in C++

那么如何定位虚表呢？编译器另外还为每个对象提供了一个虚表指针(即vptr)，这个指针指向了对象所属类的虚表，在程序运行时，根据对象的类型去初始化vptr，从而让vptr正确的指向了所属类的虚表，从而在调用虚函数的时候，能够找到正确的函数，对于第二段代码程序，由于pFather实际指向的对象类型是Son，因此vptr指向的Son类的vtable，当调用pFather->Son()时，根据虚表中的函数地址找到的就是Son类的Say()函数.

　　正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的，换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数，那么虚表指针是在什么时候，或者什么地方初始化呢？

　　答案是在构造函数中进行虚表的创建和虚表指针的初始化，在构造子类对象时，要先调用父类的构造函数，此时编译器只“看到了”父类，并不知道后面是否还有继承者，它初始化父类对象的虚表指针，该虚表指针指向父类的虚表，当执行子类的构造函数时，子类对象的虚表指针被初始化，指向自身的虚表。

　　总结(基类有虚函数的):

　　1:每一个类都有虚表

　　2:虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现，如果基类有3个虚函数，那么基类的虚表中就有三项(虚函数地址)，派生类也会虚表，至少有三项，如果重写了相应的虚函数，那么虚表中的地址就会改变，指向自身的虚函数实现，如果派生类有自己的虚函数，那么虚表中就会添加该项。

　　3：派生类的虚表中虚地址的排列顺序和基类的虚表中虚函数地址排列顺序相同。

　　这就是c++中的多态性，当c++编译器在编译的时候，发现Father类的Say()函数是虚函数，这个时候c++就会采用晚绑定技术，也就是编译时并不确定具体调用的函数，而是在运行时，依据对象的类型来确认调用的是哪一个函数，这种能力就叫做c++的多态性，我们没有在Say()函数前加virtual关键字时，c++编译器就确定了哪个函数被调用，这叫做早期绑定。

　　c++的多态性就是通过晚绑定技术来实现的。

　　c++的多态性用一句话概括就是:在基类的函数前加上virtual关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数，如果对象类型是派生类，就调用派生类的函数，如果对象类型是基类，就调用基类的函数。

　　虚函数是在基类中定义的，目的是不确定它的派生类的具体行为，例如:

　　定义一个基类:class Animal //动物，它的函数为breathe()

　　再定义一个类class Fish //鱼。它的函数也为breathe()

　　再定义一个类class Sheep //羊，它的函数也为breathe()

将Fish，Sheep定义成Animal的派生类，然而Fish与Sheep的breathe不一样，一个是在水中通过水来呼吸，一个是直接呼吸，所以基类不能确定该如何定义breathe，所以在基类中只定义了一个virtual breathe，它是一个空的虚函数，具体的函数在子类中分别定义，程序一般运行时，找到类，如果它有基类，再找到它的基类，最后运行的是基类中的函数，这时，它在基类中找到的是virtual标识的函数，它就会再回到子类中找同名函数，派生类也叫子类，基类也叫父类，这就是虚函数的产生，和类的多态性的体现。

　　这里的多态性是指类的多态性。

　　函数的多态性是指一个函数被定义成多个不同参数的函数。当你调用这个函数时，就会调用不同的同名函数。

一般情况下(不涉及虚函数)，当我们用一个指针/引用调用一个函数的时候，被调用的函数是取决于这个指针/引用的类型。

当设计到多态性的时候，采用了虚函数和动态绑定，此时的调用就不会在编译时候确定而是在运行时确定。不在单独考虑指针/引用的类型而是看指针/引用的对象的类型来判断函数的调用，根据对象中虚指针指向的虚表中的函数的地址来确定调用哪个函数

现在我们看一个体现c++多态性的例子，看看输出结果:

#include <iostream> #include <stdlib.h>using namespace std; 

class CA 
{ 
public: 
    void f() 
    { 
        cout << "CA f()" << endl; 
    } 
    virtual void ff() 
    { 
        cout << "CA ff()" << endl; 
        f(); 
    } 
}; 

class CB : public CA 
{ 
public : 
    virtual void f() 
    { 
        cout << "CB f()" << endl; 
    } 
    void ff() 
    { 
        cout << "CB ff()" << endl; 
        f(); 
        CA::ff(); 
    } 
}; 
class CC : public CB 
{ 
public: 
    virtual void f() 
    { 
        cout << "C f()" << endl; 
    } 
}; 

int main() 
{ 
    CB b; 
    CA *ap = &b; 
    CC c; 
    CB &br = c; 
    CB *bp = &c; 

    ap->f(); 
    cout << endl;

    b.f(); 
    cout << endl;

    br.f(); 
    cout << endl;

    bp->f(); 
    cout << endl;

    ap->ff(); 
    cout << endl;

    bp->ff(); 
    cout << endl;    return 0; 
}

Nach dem Login kopieren

输出结果:

CA f()CB f()C f()C f()CB ff()CB f()CA ff()CA f()CB ff()C f()CA ff()CA f()

Nach dem Login kopieren