【C++学习笔记】静态多态与动态多态

#include 
using namespace std;
 
//两个函数构成重载
int add(int a, int b)
{
  cout<<"in add_int_int()"<
T add(T a, T b)
{
  cout<<"in func tempalte"<('A',' ')<

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29

程序输出结果：

in add_int_int()
2
in add_double_doube()
2.2
in func tempalte
a
1
2
3
4
5
6

4.动态多态

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

#include 
using namespace std;
 
class Base
{
public:
  virtual void func()
{
    cout << "Base::fun()" << endl;
  }
};
 
class Derived : public Base
{
public:
  virtual void func()
{
   cout << "Derived::fun()" << endl;
  }
};
 
int main()
{
  Base* b=new Derived;     //使用基类指针指向派生类对象
  b->func();               //动态绑定派生类成员函数func
  
  Base& rb=*(new Derived); //也可以使用引用指向派生类对象
  rb.func();        
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

通过上面的例子可以看出，在使用基类指针或引用指向子类对象时，调用的函数是子类中重写的函数，这样就实现了运行时函数地址的动态绑定，即动态联编。动态多态是通过“继承+虚函数”来实现的，只有在程序运行期间（非编译期）才能判断所引用对象的实际类型，根据其实际类型调用相应的方法。具体格式就是使用virtual关键字修饰类的成员函数时，指明该函数为虚函数，并且派生类需要重新实现该成员函数，编译器将实现动态绑定。

5.总结

应用形式上：

• 静态多态是发散式的，让相同的实现代码应用于不同的场合。

• 动态多态是收敛式的，让不同的实现代码应用于相同的场合。

思维方式上：

• 静态多态是泛型式编程风格，它看重的是算法的普适性。

• 动态多态是对象式编程风格，它看重的是接口和实现的分离度。