C++ 多态

C++ 多态

 

多态 多态性能够简单地概括为“一个接口，多种方法”，程序在执行时才决定调用的函数，

 

 

   C++多态性是通过虚函数来实现的，虚函数同意子类又一次定义成员函数，而子类又一次定义父类的做法称为覆盖(override)，或者称为重写。

   重写的话分为有两种，直接重写成员函数和重写虚函数，仅仅有重写了虚函数的才干算作是体现了C++多态性，而重载则是同意有多个同名的函数，而这些函数的參数列表不同，同意參数个数不同，參数类型不同，或者两者都不同。编译器会依据这些函数参数的不同列表，将同名的函数的名称做修饰，从而生成一些不同名称的预处理函数，来实现同名函数调用时的重载问题。但这并没有体现多态性。
　　多态与非多态的实质差别就是函数地址是早绑定还是晚绑定。假设函数的调用，在编译器编译期间就能够确定函数的调用地址，并生产代码，是静态的，就是说地址是早绑定的。而假设函数调用的地址不能在编译器期间确定，须要在执行时才确定，这就属于晚绑定。
　　那么多态的作用是什么呢，封装能够使得代码模块化，继承能够扩展已存在的代码，他们的目的都是为了代码重用。而多态的目的则是为了接口重用。也就是说，不论传递过来的到底是那个类的对象，函数都能够通过同一个接口调用到适应各自对象的实现方法。

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

静态多态 

  静态多态是编译器在编译期间完成的，编译器根据函数实参的类型(可能会进行隐式类型的转换)，可推断出要调用哪个函数，如果有对应的函数就调用该函数，否则出现编译错误

我们以前说过的函数重载就是一个简单的静态多态。

int Add(int left, int right)
{
    return left + right;
}
double Add(double left, int right)
{
    return left + right;
}

int main()
{
    Add(10, 20);
    //Add(10.0, 20.0);  //这是一个问题代码
    Add(10.0,20);  //正常代码
    return 0;
}

可以看出来，静态多态是编译器在编译期间完成的，编译器会根据实参类型来选择调用合适的函数，如果有合适的函数可以调用就调，没有的话就会发出警告或者报错。

动态多态

（1）动态多态的实现条件：

--基类中必须包含虚函数，并且派生类一定要对基类中的虚函数进行重写

 --通过基类对象的指针或引用调用虚函数

 

所谓重写是：

a.基类函数必须为虚函数

 b.派生类函数必须与基类中的虚函数保持一致(包括返回类型、函数名称、参数列表)

 

但是有例外：即协变：

第一种是：基类虚函数必须返回基类对象的指针/引用，派生类虚函数返回派生类对象的指针/引用   

 第二种是：虚拟的析构函数(基类和派生类的析构函数名字不相同)  

 第三种是：派生类的虚函数可以与基类中的虚函数访问限定符不一样

 

总结一道面试题：那些函数不能定义为虚函数？ 
经检验下面的几个函数都不能定义为虚函数： 
1）友元函数，它不是类的成员函数 
2）全局函数 
3）静态成员函数，它没有this指针 
3）构造函数，拷贝构造函数，以及赋值运算符重载（可以但是一般不建议作为虚函数）

 

C++ 动态多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。

#include <iostream> 
using namespace std;
 
class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};
class Rectangle: public Shape{
   public:
      Rectangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Rectangle class area :" <<endl;
         return (width * height); 
      }
};
class Triangle: public Shape{
   public:
      Triangle( int a=0, int b=0):Shape(a, b) { }
      int area ()
      { 
         cout << "Triangle class area :" <<endl;
         return (width * height / 2); 
      }
};
// 程序的主函数
int main( )
{
   Shape *shape;
   Rectangle rec(10,7);
   Triangle  tri(10,5);
 
   // 存储矩形的地址
   shape = &rec;
   // 调用矩形的求面积函数 area
   shape->area();
 
   // 存储三角形的地址
   shape = &tri;
   // 调用三角形的求面积函数 area
   shape->area();
   
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Parent class area
Parent class area

导致错误输出的原因是，调用函数 area() 被编译器设置为基类中的版本，这就是所谓的静态多态，或静态链接 - 函数调用在程序执行前就准备好了。有时候这也被称为早绑定，因为 area() 函数在程序编译期间就已经设置好了。

但现在，让我们对程序稍作修改，在 Shape 类中，area() 的声明前放置关键字 virtual，如下所示：

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      virtual int area()
      {
         cout << "Parent class area :" <<endl;
         return 0;
      }
};

修改后，当编译和执行前面的实例代码时，它会产生以下结果：

Rectangle class area
Triangle class area

此时，编译器看的是指针的内容，而不是它的类型。因此，由于 tri 和 rec 类的对象的地址存储在 *shape 中，所以会调用各自的 area() 函数。

正如您所看到的，每个子类都有一个函数 area() 的独立实现。这就是多态的一般使用方式。有了多态，您可以有多个不同的类，都带有同一个名称但具有不同实现的函数，函数的参数甚至可以是相同的。

另一个例子：

 

class TakeBus
{
public:
    void TakeBusToSubway()
    {
        cout << "go to Subway--->please take bus of 318" << endl;
    }
    void TakeBusToStation()
    {
        cout << "go to Station--->pelase Take Bus of 306 or 915" << endl;
    }
};
//知道了去哪要做什么车可不行，我们还得知道有没有这个车
class Bus
{
public:
    virtual void TakeBusToSomewhere(TakeBus& tb) = 0;  //？？？为什么要等于0
};

class Subway:public Bus
{
public:
    virtual void TakeBusToSomewhere(TakeBus& tb)
    {
        tb.TakeBusToSubway();
    }
};
class Station :public Bus
{
public:
    virtual void TakeBusToSomewhere(TakeBus& tb)
    {
        tb.TakeBusToStation();
    }
};

int main()
{
    TakeBus tb;
    Bus* b = NULL;
    //假设有十辆公交车，如果是奇数就是去地铁口的，反之就是去火车站的
    for (int i = 1; i <= 10; ++i)
    {
        if ((rand() % i) & 1)
            b = new Subway;
        else
            b = new Station;
    }
    b->TakeBusToSomewhere(tb);
    delete b;
    return 0;
}

 

这就是一个简单的动态多态的例子，它是在程序运行时根据条件去选择调用哪一个函数。 
而且，从上面的例子我们还发现了我在每一个函数前都加了virtual这个虚拟关键字，想想为什么？如果不加会不会构成多态呢？ 
干想不如上机实践：

 

 

class Base
{
public:
    virtual void Funtest1(int i)
    {
        cout << "Base::Funtest1()" << endl;
    }
    void Funtest2(int i)
    {
        cout << "Base::Funtest2()" << endl;
    }
};
class Drived :public Base
{
    virtual void Funtest1(int i)
    {
        cout << "Drived::Fubtest1()" << endl;
    }
    virtual void Funtest2(int i)
    {
        cout << "Drived::Fubtest2()" << endl;
    }
    void Funtest2(int i)
    {
        cout << "Drived::Fubtest2()" << endl;
    }
};
void TestVirtual(Base& b)
{
    b.Funtest1(1);
    b.Funtest2(2);
}
int main()
{
    Base b;
    Drived d;
    TestVirtual(b);
    TestVirtual(d);
    return 0;
}

 

结果：

Base::Funtest1()
Base::Funtest2()
Drived::Funtest1()
Base::Funtest2()

在调用FuncTest2的时候我们看出来他并没有给我们调用派生类的函数

 

虚函数

虚函数 是在基类中使用关键字 virtual 声明的函数。在派生类中重新定义基类中定义的虚函数时，会告诉编译器不要静态链接到该函数。

我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数，这种操作被称为动态链接，或后期绑定。

纯虚函数

您可能想要在基类中定义虚函数，以便在派生类中重新定义该函数更好地适用于对象，但是您在基类中又不能对虚函数给出有意义的实现，这个时候就会用到纯虚函数。

我们可以把基类中的虚函数 area() 改写如下：

class Shape {
   protected:
      int width, height;
   public:
      Shape( int a=0, int b=0)
      {
         width = a;
         height = b;
      }
      // pure virtual function
      virtual int area() = 0;
};

= 0 告诉编译器，函数没有主体，上面的虚函数是纯虚函数。