C++多态性

标签：type   存在   mes   false   names   固定   常见   原理   派生类   

1.1 多态性的概念

 　　在面向对象语言中，接口的多种不同实现方式即为多态，可以简单地概括为“一个接口，多种方法”。

　　多态性（polymorphism）是面向对象程序设计的一个重要特征。如果一种语言只支持类而不支持多态，是不能被称为面向对象语言的，只能说是基于对象的。

　　引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作（摘自“Delphi4 编程技术内幕”）。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数实现的。

1.2 形式

 　　多态：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在运行时，可以通过指向基类的指针，来调用实现派生类中的方法。多态就是允许方法重名，参数或返回值可以是父类型传入或返回。

　　C++中的多态性具体体现在运行和编译两个方面。运行时多态是动态多态，其具体引用的对象在运行时才能确定。编译时多态是静态多态，在编译时就可以确定对象使用的形式。多态与非多态的实质区别就是函数地址是早绑定还是晚绑定。如果函数的调用，在编译器编译期间就可以确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而如果函数调用的地址不能在编译器期间确定，需要在运行时才确定，这就属于晚绑定。

　　而重载则是允许有多个同名的函数，而这些函数的参数列表不同，允许参数个数不同，参数类型不同，或者两者都不同。编译器会根据这些函数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。

　　最常见的用法就是声明基类的指针，利用该指针指向任意一个子类对象，调用相应的虚函数，可以根据指向的子类的不同而实现不同的方法。如果没有使用虚函数的话，即没有利用C++多态性，则利用基类指针调用相应的函数的时候，将总被限制在基类函数本身，而无法调用到子类中被重写过的函数。因为没有多态性，函数调用的地址将是一定的，而固定的地址将始终调用到同一个函数，这就无法实现一个接口，多种方法的目的了。

#include<iostream>  

using namespace std;  

class A  

{  

public:  

void foo()  

    {  

        printf("1\n");  

    }  

virtual void fun()  

    {  

        printf("2\n");  

    }  

};  

class B : public A  

{  

public:  

void foo()  

    {  

        printf("3\n");  

    }  

void fun()  

    {  

        printf("4\n");  

    }  

};  

int main(void)  

{  

    A a;  

    B b;  

    A *p = &a;  

    p->foo();  

    p->fun();  

    p = &b;  

    p->foo();  

    p->fun();  

return 0;  

}

　　第一个p->foo()和p->fuu()都很好理解，本身是基类指针，指向的又是基类对象，调用的都是基类本身的函数，因此输出结果就是1、2。
 　  第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象，正式体现多态的用法，p->foo()由于指针是个基类指针，指向是一个固定偏移量的函数，因此此时指向的就只能是基类的foo()函数的代码了，因此输出的结果还是1。而p->fun()指针是基类指针，指向的fun是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fun()并不是直接调用函数，而是通过虚函数列表找到相应的函数的地址，因此根据指向的对象不同，函数地址也将不同，这里将找到对应的子类的fun()函数的地址，因此输出的结果也会是子类的结果4。

　　实例的另类测试方法。即
       B *ptr = (B *)&a;  ptr->foo();  ptr->fun();
　　问这两调用的输出结果。这是一个用子类的指针去指向一个强制转换为子类地址的基类对象。结果，这两句调用的输出结果是3，2。
　　并不是很理解这种用法，从原理上来解释，由于B是子类指针，虽然被赋予了基类对象地址，但是ptr->foo()在调用的时候，由于地址偏移量固定，偏移量是子类对象的偏移量，于是即使在指向了一个基类对象的情况下，还是调用到了子类的函数，虽然可能从始到终都没有子类对象的实例化出现。
　　而ptr->fun()的调用，可能还是因为C++多态性的原因，由于指向的是一个基类对象，通过虚函数列表的引用，找到了基类中fun()函数的地址，因此调用了基类的函数。由此可见多态性的强大，可以适应各种变化，不论指针是基类的还是子类的，都能找到正确的实现方法。

    //小结：1、有virtual才可能发生多态现象  
    // 2、不发生多态（无virtual）调用就按原类型调用  
    #include<iostream>  
    using namespace std;  
      
    class Base  
    {  
    public:  
        virtual void f(float x)  
        {  
            cout<<"Base::f(float)"<< x <<endl;  
        }  
        void g(float x)  
        {  
            cout<<"Base::g(float)"<< x <<endl;  
        }  
        void h(float x)  
        {  
            cout<<"Base::h(float)"<< x <<endl;  
        }  
    };  
    class Derived : public Base  
    {  
    public:  
        virtual void f(float x)  
        {  
            cout<<"Derived::f(float)"<< x <<endl;   //多态、覆盖  
        }  
        void g(int x)  
        {  
            cout<<"Derived::g(int)"<< x <<endl;     //隐藏  
        }  
        void h(float x)  
        {  
            cout<<"Derived::h(float)"<< x <<endl;   //隐藏  
        }  
    };  
    int main(void)  
    {  
        Derived d;  
        Base *pb = &d;  
        Derived *pd = &d;  
        // Good : behavior depends solely on type of the object  
        pb->f(3.14f);   // Derived::f(float) 3.14  
        pd->f(3.14f);   // Derived::f(float) 3.14  
      
        // Bad : behavior depends on type of the pointer  
        pb->g(3.14f);   // Base::g(float)  3.14  
        pd->g(3.14f);   // Derived::g(int) 3   
      
        // Bad : behavior depends on type of the pointer  
        pb->h(3.14f);   // Base::h(float) 3.14  
        pd->h(3.14f);   // Derived::h(float) 3.14  
        return 0;  
    }  

C++多态性

标签：type   存在   mes   false   names   固定   常见   原理   派生类   

原文地址：https://www.cnblogs.com/Lucas-wang/p/9090343.html