C++特性之多态性

C++多态性概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。

C++多态性是通过虚函数来实现的，虚函数允许子类重新定义成员函数，而子类重新定义父类的做法成为覆盖或者重写，（重写可以有两种，直接重写成员函数和重写虚函数，只有重写了虚函数的才能算作体现了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;

}

输出结果：

1

2

1

4

p是基类指针指向子类对象，体现了多态的用法，p->foo()由于指针是个基类指针，指向是一个固定偏移量的函数，因此此时指向的就只能是基类的foo()函数，因此输出的结果还是1，而p->fun()指针是基类指针，指向的fun是一个虚函数，由于每个虚函数都有一个虚函数列表，此时p调用fun()并不是直接调用函数，而通过虚函数列表找到相应的函数地址，因此根据指向的对象不同，函数地址也不同，这里将找到对应的子类fun()函数地址。

B *ptr = (B *)&a; ptr->foo(); ptr->fun();

这是用子类的指针指向一个强制转换为子类地址的基类对象，结果输出是3，2

由于ptr是子类指针，虽然被赋予基类对象地址，但是ptr->foo()在调用的时候，由于地址偏移量固定，偏移量是子类对象的偏移量，于是即使在指向了一个基类对象的情况下，还是调用了子类的函数。而ptr->fun()的调用，因为C++多态性的原因，由于指向的是一个基类对象，通过虚函数列表的引用，找到了基类中fun()函数的地址，因此调用了基类的函数。

#include<iostream>

using namespace std;

class Base

{

public:

virtual void f(float x)

{

printf("Base:f(float)");

}

void g(float x)

{

printf("Base:g(float)");

}

void h(float x)

{

printf("Base:h(float)");

}

};

class Derived : public Base

{

public:

 virtual void f(float x)

{

printf("Derived:f(float)");

}

void g(int x)

{

printf("Derived:g(float)");

}

void h(float x)

{

printf("Derived:h(float)");

}

}

int main(void)

{

Derived d;

Base *pb = &d;

Derived* pd = &d;

pb->f(3.14);

pd->f(3.14);

pb->g(3.14);

pd->g(3.14);

pb->h(3.14);

pd->h(3.14);

return 0;

}

本来区别重载与覆盖并不困难。但是C++的隐藏规则使问题复杂了

这里隐藏是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

1）、如果派生类的函数与基类的函数同名，但是参数不同，此时，不论有无virtual关键字，基类的函数将被隐藏f

2）、如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字，此时基类的函数被隐藏

因此，函数Derived::f(float)覆盖了Base::f(float)

函数Derived::g(int)隐藏了Base::g(float)，而不是重载

函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖