C++多态性

多态，英文为Polymorphism，目的是将接口与实现分离，提供同一个接口，根据不同的情况，使用不同的实现策略。

函数的重载（overload）属于多态性，方法覆盖（override）属于多态性，虚函数（virtual关键字）同样也是为了实现多态性。

重载的例子（这里为了强调多态技术本身，例子尽量简单了）：

#include <iostream>

using std::cout;
using std::endl;

static inline void foo(void) {
cout << "foo version1\n";
}

static inline void foo(int a) {
cout << "foo version2: arg is " << a << endl;
}

static inline void foo(int a, char *str) {
cout << "foo version3: arg is " << a << ", " << str << endl;
}

int main(void)
{
foo();
foo(1);
foo(3, "hahaa");

return 0;
}

程序的输出结果是

[root@localhost overload]# ./a.out 
foo version1
foo version2: arg is 1
foo version3: arg is 3, hahaa

同样，类中的方法也可以重载，下面是一个简单的例子

#include <iostream>

using namespace std;

class foo {

public:
void test(void) {
cout << "test version 1: no arg\n";
};
void test(int arg) {
cout << "test version 2: arg is " << arg << endl;
};
};

int main(void)
{
foo f;

f.test();
f.test(100);

return 0;
}

程序输出结果是：

[root@localhost overload]# ./a.out 
test version 1: no arg
test version 2: arg is 100< 4000 /span>

再来一个方法覆盖的例子：

#include <iostream>

using namespace std;

class foo {
public:
void test(void) {
cout << "Base class test method.\n";
};
};

class bar : public foo {
public:
void test(void) {
cout << "Derived class test method v1.\n";
};
void test(int v) {
cout << "Derived class test method v2.\n";
};
};

int main(void)
{
foo f;
bar b;

f.test();
b.test();
b.test(1);

return 0;
}

程序输出结果： [root@localhost overload]# ./a.out 
Base class test method.
Derived class test method v1.
Derived class test method v2.

最后说虚函数，虚函数相对来说复杂些，先简单介绍下背景。

基类指针或引用可以指向派生类对象，例如当使用基类指针调用派生类覆盖的方法，则会调用基类的实现，而不是派生类的方法，为了调用派生类的方法，也就是说使用实际指向的对象的方法，而不是指针类型对应方法，则可以在基类的方法前加上virtual关键字，使该方法称为一个虚方法，从而使程序在运行时决定调用哪个方法（也就是根据运行时实际对象的类型），例子如下

#include <iostream>

using namespace std;

class foo {
public:
//虚方法
virtual void virtual_m(void) {
cout << "Base class method, virtual version!" << endl;
};
void nonvirtual_m(void) {
cout << "Base class method, nonvirtual version!" << endl;
};
};

class bar: public foo {
public:
void virtual_m(void) {
//void virtual_m(void) const { //加了const在某些c++实现上可能导致基类virtal无效
cout << "Derived class method, virtual!" << endl;
};
void nonvirtual_m(void) {
cout << "Derived class method, nonvirtual!" << endl;
};
};

int main(void)
{
foo f;
bar b;

cout << "=============================\n";
f.virtual_m();
f.nonvirtual_m();

cout << "=============================\n";
b.virtual_m();
b.nonvirtual_m();

cout << "=============================\n";
//基类指针指向派生类对象
foo *a = &b;
a->virtual_m();     //将调用派生类方法
a->nonvirtual_m();  //将调用基类方法

return 0;
}

程序输出，注意颜色特殊的输出，就是调用了实际对象类型的方法： [root@localhost 1]# ./a.out 
=============================
Base class method, virtual version!
Base class method, nonvirtual version!
=============================
Derived class method, virtual!
Derived class method, nonvirtual!
=============================
Derived class method, virtual!
Base class method, nonvirtual version!

阅读更多