Statischer Polymorphismus hängt mit dynamischem Polymorphismus und virtuellen Funktionen zusammen

Was ist Polymorphismus?

Wörtlich bedeutet es mehrere Formen. Das Wort Polymorphismus stammt ursprünglich aus dem Griechischen und bedeutet „mehrere Formen“, was eine Situation mit mehreren Formen oder Gestalten bedeutet. In der Sprache C++ hat Polymorphismus ein breiteres Bedeutungsspektrum. Im C++-Grundlagenbuch werden mehrere Typen mit Vererbungsbeziehungen als polymorphe Typen bezeichnet, da wir „verschiedene Formen“ dieser Typen verwenden können, ohne uns um ihre Unterschiede zu kümmern. Baidu Encyclopedia erwähnt, dass in der objektorientierten-Sprache die verschiedenen Implementierungen der Schnittstelle polymorph sind. ZitatCharlie Calverts‘ Beschreibung des Polymorphismus – Polymorphismus ist eine Technik, die es Ihnen ermöglicht, ein übergeordnetes Objekt so festzulegen, dass es einem oder mehreren seiner untergeordneten Objekte entspricht. Nach der Zuweisung kann das übergeordnete Objekt auf dem aktuellen basieren Zuweisungseigenschaften, die ihren Unterobjekten zugewiesen werden, verhalten sich unterschiedlich. Einfach ausgedrückt ist es ein Satz: Es ist erlaubt, einen Zeiger eines Unterklassentyps einem Zeiger eines übergeordneten Klassentyps zuzuweisen. Polymorphismus wird sowohl in Object Pascal als auch in C++ durch virtuelle Funktionen implementiert.
Es ist unmöglich, es nur anhand der konzeptionellen Beschreibung tiefgreifend und klar zu verstehen. Lassen Sie es uns unten im Detail analysieren.

1. Objekttyp

Der hier erwähnte Objekttyp kann durch das folgende Bild widergespiegelt werden: Lassen Sie es uns anhand von Codebeispielen veranschaulichen

 1 class Derived1:public Base 2 {}; 3 class Derived2:public Base 4 {}: 5 int main() 6 { 7      Derived1* p1 = new Derived1; 8      Base = p1; 9      Derived2* p2 = new Derived1;10      Base = p2;11      return = p212 }

Der statische -Typ ist zur Kompilierungszeit immer bekannt. Es handelt sich um den Typ der Variable bei der Deklaration oder des generierten Ausdrucks Der Typ; der dynamische Typ ist der Typ des Objekts im Speicher, das durch die Variable oder den Ausdruck dargestellt wird. Dynamische Typen sind erst zur Laufzeit bekannt.

2. Statischer Polymorphismus und dynamischer Polymorphismus

Der Unterschied zwischen statischem Polymorphismus und dynamischem Polymorphismus kann in der folgenden Abbildung dargestellt werden:

Statischer Polymorphismus Zustand

Statischer Polymorphismus wird auch als statische Bindung oder frühe Bindung bezeichnet. Der Compiler vervollständigt es während der Kompilierung. Der Compiler kann anhand des Typs des Funktionsarguments ableiten, welche Funktion aufgerufen werden soll (kann eine implizite Typkonvertierung durchführen) und die Funktion aufrufen, wenn eine entsprechende Funktion vorhanden ist Andernfalls kommt es zu einem Kompilierungsfehler.

 1 int Add(int left,int right) 2 { 3      return left + right; 4 } 5 float Add(float left, float right) 6 { 7      return left + right; 8 } 9 int main()10 {   
11     cout<<Add(1,2)<<endl;  //调用int Add()函数12     cout<<Add(1.34f,3.21f)<<endl; //调float Add()函数13     return 0;14 }

Hier klassifiziere ich Überladung als statischen Polymorphismus. Die Implementierung der Überladung ist: Der Compiler ändert die Namen von Funktionen mit demselben Namen basierend auf unterschiedlichen Parameterlisten der Funktionen, und dann werden diese Funktionen mit demselben Namen zu unterschiedlichen Funktionen (zumindest für den Compiler). Der Funktionsaufruf wurde zwischen Compilern festgelegt und ist statisch (denken Sie daran: er ist statisch). Mit anderen Worten: Ihre Adressen werden zur Kompilierzeit gebunden (frühe Bindung). Gerade aufgrund dieser Art der Überladung kommen manche Leute zu dem Schluss, dass Überladung nur ein Sprachmerkmal ist und nichts mit Polymorphismus oder Objektorientierung zu tun hat. Basierend auf der objektorientierten Programmierung gehört das Konzept der Überladung nicht zur „objektorientierten Programmierung “. Aber Polymorphismus ist ein relativ weit gefasstes Konzept. Um das Verständnis zu erleichtern, werden wir ihre Unterschiede hier nicht eingehend analysieren. Wir werden darüber sprechen, nachdem die detaillierte Analyse der und anderer Teile des Polymorphismus abgeschlossen ist.

Dynamischer Polymorphismus

Dynamische Bindung: Bestimmen Sie den tatsächlichen Typ des referenzierten Objekts während der Programmausführung (nicht während der Kompilierung) und rufen Sie die entsprechende Methode entsprechend ihrem tatsächlichen Typ auf. Wenn das Schlüsselwort virtual zum Ändern einer Mitgliedsfunktion einer Klasse verwendet wird, bedeutet dies, dass es sich bei der Funktion um eine virtuelle Funktion handelt und die abgeleitete Klasse erneut implementiert werden muss und der Compiler die dynamische Bindung implementiert.

              FunTest1(         cout <<  <<       FunTest2(         cout <<  <<        FunTest3(         cout <<  <<        FunTest4(         cout <<  <<    CDerived :              FunTest1(         cout <<  <<        FunTest2(         cout <<  <<       FunTest3( _iTest1) { cout <<  <<        FunTest4( _iTest1,          cout <<  <<        CBase* pBase =      pBase->FunTest1(     pBase->FunTest2(     pBase->FunTest3(     pBase->FunTest4(        }

Wenn wir einen Basisklassenzeiger oder eine Referenz verwenden, um eine in der Basisklasse definierte Funktion aufzurufen, wissen wir nicht, was das eigentliche Objekt ist Die Funktion hat den Typ „Welcher“, da sie ein Objekt einer Basisklasse oder ein Objekt einer abgeleiteten Klasse sein kann. Wenn es sich bei der Funktion um eine virtuelle Funktion handelt, weiß sie erst zur Laufzeit, welche Version ausgeführt wird. Die Beurteilung basiert auf dem realen Typ des Objekts, an das die Referenz oder der Zeiger gebunden ist.

Destruktor, statische Typfunktion, Friend-Funktion, Inline-Funktion und virtuelle Funktion

        CTest&  =( CTest&       *     fri end voi d FunTestFri end() ;
12 }

什么是虚函数

其实在前面的虚拟继承中我们已经用到了虚函数这个概念，在那里我们是为了解决菱形普通继承中访问二义性的问题，但在多态中，他有更大的作用。百度百科中对虚函数是这么说的：在某基类中声明为 virtual 并在一个或多个派生类中被重新定义的成员函数，用法格式为：virtual 函数返回类型 函数名（参数表） {函数体}；实现多态性，通过指向派生类的基类指针或引用，访问派生类中同名覆盖成员函数。形象的解释为“求同存异”，它的作用就是实现多态性。

简单地说，那些被virtual关键字修饰的成员函数，就是虚函数。虚函数的作用，用专业术语来解释就是实现多态性（Polymorphism），多态性是将接口与实现进行分离；用形象的语言来解释就是实现以共同的方法，但因个体差异，而采用不同的策略。

 1 class A 2 { 3     public: 4         virtual void print(){cout<<"This is A"<<endl;} 5 }; 6 class B : public A 7 { 8     public: 9     void print(){cout<<"ThisisB"<<endl;}10 };11 int main()12 {13     A a;14     B b;15     A *p1 = &a;16     A *p2 = &b;17     p1->print();18     p2->print();19     return 0;20 }

毫无疑问，class A的成员函数print（）已经成了虚函数，那么class B的print（）成了虚函数了吗？回答是Yes，我们只需在把基类的成员函数设为virtual，其派生类的相应的函数也会自动变为虚函数。所以，class B的print()也成了虚函数。那么对于在派生类的相应函数前是否需要用virtual关键字修饰，那就是你自己的问题了（语法上可加可不加，不加的话编译器会自动加上，但为了阅读方便和规范性，建议加上）。

运行代码，输出的结果是This is A和This is B。

总结：指向基类的指针在操作它的多态类对象时，会根据不同的类对象，调用其相应的函数，这个函数就是虚函数。

析构函数与虚函数

当在析构函数前面加virtual关键字时报错：，我们来分析一下原因。

1、虚函数的执行依赖于虚函数表。而虚函数表在构造函数中进行初始化工作，即初始化vptr，让他指向正确的虚函数表。而在构造对象期间，虚函数表还没有被初 始化，将无法进行。

2、构造一个对象的时候，必须知道对象的实际类型，而虚函数行为是在运行期间确定实际类型的。而在构造一个对象时，由于对象还未构造成功。编译器无法知道对象 的实际类型，是该类本身，还是该类的一个派生类，或是更深层次的派生类。无法确定。

虚函数的意思就是开启动态绑定，程序会根据对象的动态类型来选择要调用的方法。然而在构造函数运行的时候，这个对象的动态类型还不完整，没有办法确定它到底是什么类型，故构造函数不能动态绑定。（动态绑定是根据对象的动态类型而不是函数名，在调用构造函数之前，这个对象根本就不存在，它怎么动态绑定？）
编译器在调用基类的构造函数的时候并不知道你要构造的是一个基类的对象还是一个派生类的对象。

静态类型函数与虚函数

当我们在静态类型函数前加virtual关键字时报错：分析：

1、 static成员不属于任何类对象或类实例，所以即使给此函数加上virutal也是没有任何意义的。

2、static函数没有this指针，并且不会进入虚函数表的。当通过指针或者引用调用时根本无法把this指针传递给static函数，从而无法体现出多态。静态成员函数与普通成员函数的差别就在于缺少this指针，没有这个this指针自然也就无从知道name是哪一个对象的成员了。

友元函数与虚函数

当我们在友元函数前加virtual关键字时报错：

 因为C++不支持友元函数的继承，对于没有继承特性的函数没有虚函数的说法。

内联成员函数与虚函数

内联函数就是为了在代码中直接展开，减少函数调用花费的代价，虚函数是为了在继承后对象能够准确的执行自己的动作，这是不可能统一的。（再说了，inline函数在编译时被展开，虚函数在运行时才能动态的邦定函数）

赋值运算符的重载与虚函数

当我们把赋值运算符的重载定义为虚函数时编译可以通过，但是一般不建议这么做虽然可以将operator=定义为虚函数， 但使用时容易混淆。

1、无法给派生类的自有成员赋值；

2、调用虚函数要进行查虚表等一系列操作，效率下降。

析构函数与虚函数

析构函数设为虚函数的作用:在类的继承中，如果有基类指针指向派生类，那么用基类指针delete时，如果不定义成虚函数，派生类中派生的那部分无法析构。

 1 #include <stdafx.h> 2 #include <stdio.h> 3 class A 4 { 5     public: 6     A(); 7     virtual~A(); 8 }; 9     A::A()10     {}11     A::~A()12     {13     printf("Delete class APn");14     }15 class B : public A16 {17     public:18     B();19     ~B();20 };21     B::B()22     { }23     B::~B()24     {25     printf("Delete class BPn");26     }27 int main(int argc, char* argv[])28 {29     A *b=new B;30     delete b;31     return 0;32 }

输出结果为：Delete class B     Delete class A
如果把A的virtual去掉：那就变成了Delete class A也就是说不会删除派生类里的剩余部分内容，也即不调用派生类的虚函数

析构函数总结：

1. 如果我们定义了一个构造函数，编译器就不会再为我们生成默认构造函数了。
2. 编译器生成的析构函数是非虚的，除非是一个子类，其父类有个虚析构，此时的函数虚特性来自父类。
3. 有虚函数的类，几乎可以确定要有个虚析构函数。
4. 如果一个类不可能是基类就不要申明析构函数为虚函数，虚函数是要耗费空间的。
5. 析构函数的异常退出会导致析构不完全，从而有内存泄露。最好是提供一个管理类，在管理类中提供一个方法来析构，调用者再根据这个方法的结果决定下一步的操作。
6. 在构造函数不要调用虚函数。在基类构造的时候，虚函数是非虚，不会走到派生类中，既是采用的静态绑定。显然的是：当我们构造一个子类的对象时，先调用基类的构造函数，构造子类中基类部分，子类还没有构造，还没有初始化，如果在基类的构造中调用虚函数，如果可以的话就是调用一个还没有被初始化的对象，那是很危险的，所以C++中是不可以在构造父类对象部分的时候调用子类的虚函数实现。但是不是说你不可以那么写程序，你这么写，编译器也不会报错。只是你如果这么写的话编译器不会给你调用子类的实现，而是还是调用基类的实现。
7.在析构函数中也不要调用虚函数。在析构的时候会首先调用子类的析构函数，析构掉对象中的子类部分，然后在调用基类的析构函数析构基类部分，如果在基类的析构函数里面调用虚函数，会导致其调用已经析构了的子类对象里面的函数，这是非常危险的。
8. 记得在写派生类的拷贝函数时，调用基类的拷贝函数拷贝基类的部分。

总结：

1、 派生类重写基类的虚函数实现多态， 要求函数名 、 参数列表、 返回值完全相同。 (协变除外)。

2、 基类中定义了 虚函数， 在派生类中该函数始终保持虚函数的特性。

3、 只 有类的非静态成员 函数才能定义为虚函数， 静态成员 函数不能定义为虚函数。

4、 如果在类外定义虚函数， 只 能在声明函数时加virtual关键字， 定义时不用加。

5、 构造函数不能定义为虚函数， 虽然可以将operator=定义为虚函数， 但最好不要这么做， 使用时容易混淆。

6、 不要在构造函数和析构函数中调用虚函数， 在构造函数和析构函数中， 对象是不完整的， 可能会出现未定义的行为。

 7、 最好将基类的析构函数声明为虚函数。 ( 因为派生类的析构函数跟基类的析构函数名称不一样， 但是构成覆盖， 这里编译器做了特殊处理)

8、 虚表是所有类对象实例共用的。

Das obige ist der detaillierte Inhalt vonStatischer Polymorphismus hängt mit dynamischem Polymorphismus und virtuellen Funktionen zusammen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!