C++的多态原理和实现
2012-08-27 23:12
507 查看
面试时经常被问到一连串的问题：
1、什么是多态性？
2、多态性的原理（多态是怎么实现的）？
3、用C语言实现多态（写代码）。
首先，我们来研究一下C++面向对象的内存模型，也就是实现虚函数时类的存储结构。
1. 用 virtual 关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。
2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。 虚表是 和类对应的，虚表指针是和对象对应的。
3. 多态性是 一个接口多种实现 ，是面向对象的核心。分为类的多态性和函数的多态性。
4. 多态用虚函数来实现，结合动态绑定。
5. 纯虚函数是虚函数再加上 = 0 。
6. 抽象类是指包括至少一个纯虚函数的类。
纯虚函数： virtual void breathe()=0 ；即抽象类！必须在子类实现这个函数 ! 即先有名称，没内容，在派生类实现内容 !
我们先看一个例子：例 1- 1
#include <iostream.h>
class animal
{
public:
void sleep()
{
cout<<"animal sleep"<<endl;
}
void breathe ()
{
cout<<"animal breathe"<<endl;
}
};
class fish:public animal
{
public:
void breathe ()
{
cout<<"fish bubble"<<endl;
}
};
void main()
{
fish fh;
animal *pAn=&fh; // 隐式类型转换
pAn->breathe();
}
注意，在例 1-1 的程序中没有定义虚函数。考虑一下例 1-1 的程序执行的结果是什么？
答案是输出： animal breathe
我 们在 main() 函数中首先定义了一个 fish 类的对象 fh ，接着定义了一个指向 animal 类的指针变量 pAn ，将 fh 的地址赋给了指针变量 pAn ，然 后利用该变量调用 pAn->breathe() 。许多学员往往将这种情况和 C++ 的多态性搞混淆，认为 fh 实际上是 fish 类的对象，应该是调用 fish 类的 breathe() ，输出 “fish bubble” ，然后结果却不是这样。下面我们从两个方面来讲述原因。
1 、 编译的角度
C++ 编译器 在编译的时候，要确定每个对象调用的函数（ 要求此函数是非虚函数 ）的地址，这称为 早期绑定（ early binding ） ，当我们将 fish 类的对象 fh 的地址赋给 pAn 时， C++ 编译器 进行了类型转换 ，此时 C++ 编译器 认为变量 pAn 保存的就是 animal 对象的地址。当在 main() 函数中执行 pAn->breathe() 时，调用的当然就是 animal 对象的 breathe 函数。
2 、 内存模型的角度
我们给出了 fish 对象内存模型，如下图所示：
图 1- 1 fish 类对象的内存模型
我们构造 fish 类的对象时，首先要调用 animal 类的构造函数去构造 animal 类的对象，然后才调用 fish 类的构造函数 完成 自身部分的构造，从而拼接出一个完整的 fish 对象。当我们将 fish 类的对象转换为 animal 类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图 1-1 中的 “animal 的对象所占内存 ” 。那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存 中的 方法。因此，输出 animal breathe ，也就顺理成章了。
正如很多学员所想，在例 1-1 的程序中，我们知道 pAn 实际指向的是 fish 类的对象，我们希望输出的结果是鱼的呼吸方法，即调用 fish 类的 breathe 方法。这个时候，就该轮到虚函数登场了。
前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用 迟绑定（ late binding ） 技术。 当编译器使用迟绑定时，就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定，就要在基类中声明函数时使用 virtual 关键字 （注意，这是必须的，很多学员就是因为没有使用虚函数而写出很多错误的例子），这样的函数我们称为虚函数。 一旦某个函数在基类中声明为 virtual ，那么在所有的派生类中该函数都是 virtual ，而不需要再显式地声明为
virtual 。
下面修改例 1-1 的代码，将 animal 类 中的 breathe() 函数声明为 virtual ，如下：
例 1- 2
#include <iostream.h>
class animal
{
public:
void sleep()
{
cout<<"animal sleep"<<endl;
}
virtual void breathe ()
{
cout<<"animal breathe"<<endl;
}
};
class fish:public animal
{
public:
void breathe ()
{
cout<<"fish bubble"<<endl;
}
};
void main()
{
fish fh;
animal *pAn=&fh; // 隐式类型转换
pAn->breathe();
}
大家可以再次运行这个程序，你会发现结果是 “fish bubble” ，也就是 根据对象的类型 调用了正确的函数。
那么当我们将 breathe() 声明为 virtual 时，在背后发生了什么呢？
编译器在编译的时候，发现 animal 类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表（即 vtable ），该表是一个一维数组，在这个数组中存放每个虚函数的地址。 对于例 1-2 的程序， animal 和 fish 类都包含了一个虚函数 breathe() ，因此编译器会为这两个类都建立一个虚表，（即使子类里面没有 virtual 函数，但是其父类里面有，所以子类中也有了）。
那么 如何 定位虚表呢？编译器另外还为每个类的对象提供了一个虚表指针（即 vptr ），这个指针指向了对象所属类 的虚表 。 在程序运行时，根据对象的类型去初始化 vptr ，从而让 vptr 正确的指向所属类 的虚表 ，从而在调用虚函数时，就能够找到正确的函数。对于例 1-2 的程序，由于 pAn 实际指向的对象类型是 fish ，因此 vptr 指向的 fish 类的 vtable ，当调用 pAn->breathe() 时，根据虚表 中的 函数地址找到的就是 fish 类的 breathe() 函数。
正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。 那么虚表指针在什么时候，或者说在什么地方初始化呢？
答案是在构造函数中进行虚表的创建和虚表指针的初始化。 还记得构造函数的调用顺序吗，在构造子类对象时，要先调用父类的构造函数，此时编译器只 “ 看到了 ” 父类，并不知道后面是否后还有继承者，它初始化父类对象 的虚表 指针，该虚表指针指向父类 的虚表 。当执行子类的构造函数时，子类对象 的虚表 指针被初始化，指向自身 的虚表 。对于例 2-2 的程序来说，当 fish 类的 fh 对象构造完毕后，其内部 的虚表 指针也就被初始化为指向 fish 类 的虚表 。在类型转换后，调用 pAn->breathe() ，由于
pAn 实际指向的是 fish 类的对象，该对象内部 的虚表 指针指向的是 fish 类 的虚表 ，因此最终调用的是 fish 类的 breathe() 函数。
要注意：对于虚函数调用来说， 每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类 的虚表 。 所以在程序中，不管你的对象类型 如何 转换，但该对象内部 的虚表 指针是固定的，所以呢，才能实现动态的对象函数调用，这就是 C++ 多态性实现的原理。
总结（基类有虚函数）：
1. 每一个类都有虚表。
2. 虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果基类有 3 个虚函数，那么基类 的虚表 中就有三项（虚函数地址），派生类也会有虚表，至少有三项，如果重写了相应的虚函数，那么虚表 中的 地址就会改变，指向自身的虚函数实现。如果派生类有自己的虚函数，那么虚表中就会添加该项。
3. 派生类 的虚表 中虚函数地址的排列顺序和基类 的虚表 中虚函数地址排列顺序相同。
这就是 C++ 中的 多态性。当 C++ 编译器 在 编译的时候，发现 animal 类的 breathe() 函数是虚函数，这个时候 C++ 就会采用迟绑定（ late binding ）技术。也就是编译时并不确定具体调用的函数，而是在运行时，依据对象的类型（在程序中，我们传递的 fish 类对象的地址）来确认调用的是 哪一个函数，这种能力就叫做 C++ 的多态性。我们没有在 breathe() 函数前加 virtual 关键字时， C++ 编译器 在编译时就确定了哪个函数被调用，这叫做早期绑定（ early
binding ）。
C++ 的多态性是通过迟绑定技术来实现的。
C++ 的多态性用一句话概括就是：在基类的函数前加上 virtual 关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。
虚函数是在基类中定义的，目的是不确定它的派生类的具体行为。例：
定义一个基类： class Animal// 动物。它的函数为 breathe()// 呼吸。
再定义一个类 class Fish// 鱼 。它的函数也为 breathe()
再定义一个类 class Sheep // 羊。它的函数也为 breathe()
为了简化代码，将 Fish,Sheep 定义成基类 Animal 的派生类。
然而 Fish 与 Sheep 的 breathe 不一样，一个是在水中通过水来呼吸，一个是直接呼吸空气。所以基类不能确定该 如何 定义 breathe ，所以在基类中只定义了一个 virtual breathe, 它是一个空的虚函数。具本的函数在子类中分别定义。程序一般运行时，找到类，如果它有基类，再找它的基类，最后运行的是基类 中的 函数，这时，它在基类中找到的是 virtual 标识的函数，它就会再回到子类中找同名函数。派生类也叫子类。基类也叫父类。这就是虚函数的产生，和类的多态性（ breathe ）的体现。
这里的多态性是指类的多态性。
函 数的多态性是指一个函数被定义成多个不同参数的函数，它们一般被存在头文件中，当你调用这个函数，针对不同的参数，就会调用不同的同名函数。 例： Rect （） // 矩形。它的参数可以是两个坐标点（ point ， point) 也可能是四个坐标 (x1,y1,x2,y2) 这叫函数的多态性与函数的重 载。
类的多态性，是指用虚函数和延迟绑定来实现的。函数的多态性是函数的重载。
一般情况下（没有涉及 virtual 函数），当我们用一个指针 / 引用调用一个函数的时候，被调用的函数是取决于这个指针 / 引用的类型。即如果这个指针 / 引用是基类对象的指针 / 引用就调用基类的方法；如果指针 / 引用是派生类对象的指针 / 引用就调用派生类的方法，当然如果派生类中没有此方法，就会向上到基类里面去寻找相应的方法。这些调用在编译阶段就确定了。
当设计到多态性的时候，采用了虚函数和动态绑定，此时的调用就不会在编译时候确定而是在运行时确定。不在单独考虑指针 / 引用的类型而是看指针 / 引用的对象的类型来判断函数的调用，根据对象中虚指针指向 的虚表中的 函数的地址来确定调用哪个函数。
二、关于多态性的一些问题：
B b;
A *pa = &b;//A为基类，B为子类
pa-> foo();//foo()为虚函数
pa-> foo()会被编译为 (*pa-> vptr[1])(pa)；其中参数pa为this指针
pa的类型为A * ,应该只能访问A的成员
请问pa是怎样在虚函数里面访问B的成员的？
在进行虚函数调用时，其参数类型为foo(B * const this,...)
而实际传给该函数的为父类类型指针pa，所以编译器会进行隐式的
转换，即(B*)pa,因此在函数内部pa可以访问到B的成员。
三、用C语言实现多态（实际上就是struct内的一个函数指针）：
下面是转载
最近一直喜欢浏览国外网站,感觉收获很多,所以我跟苞谷说,看中文网站是无奇不有,看外文网站才知道世界之大.Polymorphism in C是我摘抄+修改+体会+翻译过来的好东东.有助于理解多态.
多态是什么?就是我们调用一个公共接口(相同函数名字)时,根据调用者的类型调用不同的函数,看过我之前写的C++向C的转化的人其实知道,函数名字相同只是我们肉眼看见的相同,编译器优化后,意味函数所属的class不一样,函数名字也要变化,显然函数的入口地址都是不一样的.C++中的RTTI和dynamic binding就是做这个事情.当然C也可以实现,C是C++的鼻祖嘛.
这个图中的Structs就是相当于一个class,所有有个class-like,然后每个structs里面有一个公共方法method,这个公共方法就在Common Interface里面,调用者调用这个method不用管它能否调到它想要的那个method,在C++中,可以让你的类型同你这个method绑定在一起,所以很方便,调用者直接call这个method就能call到你想用的那个方法.
其实多态就是函数指针实现的,因为C也有指针,C也可以做到.
/*file:Poly.h*/
#ifndef _POLY_H
#define _POLY_H
struct POLY_STRUCT
{
void (*poly)( ); // 多态函数,common interface
};
/* 初始化一个类(相当于),然后把这个公共函数的具体实现跟类型绑一起 */
struct POLY_STRUCT *InitPoly( void (*poly)() );
/* 释放一个类(相当于析构函数)*/
void DestroyPoly( struct POLY_STRUCT *poly );
#endif
/*file:Poly.c*/
struct POLY_STRUCT *InitPoly( void (*poly)() )
{
struct POLY_STRUCT *result = (struct POLY_STRUCT*)
malloc( sizeof( struct POLY_STRUCT ) );
if(result != NULL)
result->poly = poly;
return result;
}
void DestroyPoly( struct POLY_STRUCT *poly ){ if(poly != NULL) free(poly); }
/*file:main.c*/
/*下面是两个用父类指针表示的两个子类对象*/
struct POLY_STRUCT* example_poly1;
struct POLY_STRUCT* example_poly2;
/*定义两个函数,代表这两个子类中common interface的不同实现*/
void poly_example1_method(){printf("EXAMPLE1/n");}
void poly_example2_method(){printf("EXAMPLE2/n");}
int main(int argc, char *argv[])
{
example_poly1 = InitPoly(poly_example1_method);
example_poly2 = InitPoly(poly_example2_method);
/*父类指针调用相同的函数,但是结果呢?不一样*/
(*(example_poly1->poly))();
(*(example_poly2->poly))();
DestroyPoly(example_poly1);
DestroyPoly(example_poly2);
system("PAUSE");
return 0;
}
结果:
EXAMPLE1
EXAMPLE2
结论就是,函数指针导致了多态,它付出的代价就是程序机制的复杂性和不必要的代码开销,它的优点就是,将俗点就是呈现一致的函数名给我们(实际上编译时这个名字还是要变化),因为一致性,所以重用性和扩展性也更好了.
我喜欢那句话:优化性和可扩展性需要我们去平衡.这里也是.
1、什么是多态性？
2、多态性的原理（多态是怎么实现的）？
3、用C语言实现多态（写代码）。
首先，我们来研究一下C++面向对象的内存模型，也就是实现虚函数时类的存储结构。
1. 用 virtual 关键字申明的函数叫做虚函数，虚函数肯定是类的成员函数。
2. 存在虚函数的类都有一个一维的虚函数表叫做虚表。类的对象有一个指向虚表开始的虚指针。 虚表是 和类对应的，虚表指针是和对象对应的。
3. 多态性是 一个接口多种实现 ，是面向对象的核心。分为类的多态性和函数的多态性。
4. 多态用虚函数来实现，结合动态绑定。
5. 纯虚函数是虚函数再加上 = 0 。
6. 抽象类是指包括至少一个纯虚函数的类。
纯虚函数： virtual void breathe()=0 ；即抽象类！必须在子类实现这个函数 ! 即先有名称，没内容，在派生类实现内容 !
我们先看一个例子：例 1- 1
#include <iostream.h>
class animal
{
public:
void sleep()
{
cout<<"animal sleep"<<endl;
}
void breathe ()
{
cout<<"animal breathe"<<endl;
}
};
class fish:public animal
{
public:
void breathe ()
{
cout<<"fish bubble"<<endl;
}
};
void main()
{
fish fh;
animal *pAn=&fh; // 隐式类型转换
pAn->breathe();
}
注意，在例 1-1 的程序中没有定义虚函数。考虑一下例 1-1 的程序执行的结果是什么？
答案是输出： animal breathe
我 们在 main() 函数中首先定义了一个 fish 类的对象 fh ，接着定义了一个指向 animal 类的指针变量 pAn ，将 fh 的地址赋给了指针变量 pAn ，然 后利用该变量调用 pAn->breathe() 。许多学员往往将这种情况和 C++ 的多态性搞混淆，认为 fh 实际上是 fish 类的对象，应该是调用 fish 类的 breathe() ，输出 “fish bubble” ，然后结果却不是这样。下面我们从两个方面来讲述原因。
1 、 编译的角度
C++ 编译器 在编译的时候，要确定每个对象调用的函数（ 要求此函数是非虚函数 ）的地址，这称为 早期绑定（ early binding ） ，当我们将 fish 类的对象 fh 的地址赋给 pAn 时， C++ 编译器 进行了类型转换 ，此时 C++ 编译器 认为变量 pAn 保存的就是 animal 对象的地址。当在 main() 函数中执行 pAn->breathe() 时，调用的当然就是 animal 对象的 breathe 函数。
2 、 内存模型的角度
我们给出了 fish 对象内存模型，如下图所示：
图 1- 1 fish 类对象的内存模型
我们构造 fish 类的对象时，首先要调用 animal 类的构造函数去构造 animal 类的对象，然后才调用 fish 类的构造函数 完成 自身部分的构造，从而拼接出一个完整的 fish 对象。当我们将 fish 类的对象转换为 animal 类型时，该对象就被认为是原对象整个内存模型的上半部分，也就是图 1-1 中的 “animal 的对象所占内存 ” 。那么当我们利用类型转换后的对象指针去调用它的方法时，当然也就是调用它所在的内存 中的 方法。因此，输出 animal breathe ，也就顺理成章了。
正如很多学员所想，在例 1-1 的程序中，我们知道 pAn 实际指向的是 fish 类的对象，我们希望输出的结果是鱼的呼吸方法，即调用 fish 类的 breathe 方法。这个时候，就该轮到虚函数登场了。
前面输出的结果是因为编译器在编译的时候，就已经确定了对象调用的函数的地址，要解决这个问题就要使用 迟绑定（ late binding ） 技术。 当编译器使用迟绑定时，就会在运行时再去确定对象的类型以及正确的调用函数。而要让编译器采用迟绑定，就要在基类中声明函数时使用 virtual 关键字 （注意，这是必须的，很多学员就是因为没有使用虚函数而写出很多错误的例子），这样的函数我们称为虚函数。 一旦某个函数在基类中声明为 virtual ，那么在所有的派生类中该函数都是 virtual ，而不需要再显式地声明为
virtual 。
下面修改例 1-1 的代码，将 animal 类 中的 breathe() 函数声明为 virtual ，如下：
例 1- 2
#include <iostream.h>
class animal
{
public:
void sleep()
{
cout<<"animal sleep"<<endl;
}
virtual void breathe ()
{
cout<<"animal breathe"<<endl;
}
};
class fish:public animal
{
public:
void breathe ()
{
cout<<"fish bubble"<<endl;
}
};
void main()
{
fish fh;
animal *pAn=&fh; // 隐式类型转换
pAn->breathe();
}
大家可以再次运行这个程序，你会发现结果是 “fish bubble” ，也就是 根据对象的类型 调用了正确的函数。
那么当我们将 breathe() 声明为 virtual 时，在背后发生了什么呢？
编译器在编译的时候，发现 animal 类中有虚函数，此时编译器会为每个包含虚函数的类创建一个虚表（即 vtable ），该表是一个一维数组，在这个数组中存放每个虚函数的地址。 对于例 1-2 的程序， animal 和 fish 类都包含了一个虚函数 breathe() ，因此编译器会为这两个类都建立一个虚表，（即使子类里面没有 virtual 函数，但是其父类里面有，所以子类中也有了）。
那么 如何 定位虚表呢？编译器另外还为每个类的对象提供了一个虚表指针（即 vptr ），这个指针指向了对象所属类 的虚表 。 在程序运行时，根据对象的类型去初始化 vptr ，从而让 vptr 正确的指向所属类 的虚表 ，从而在调用虚函数时，就能够找到正确的函数。对于例 1-2 的程序，由于 pAn 实际指向的对象类型是 fish ，因此 vptr 指向的 fish 类的 vtable ，当调用 pAn->breathe() 时，根据虚表 中的 函数地址找到的就是 fish 类的 breathe() 函数。
正是由于每个对象调用的虚函数都是通过虚表指针来索引的，也就决定了虚表指针的正确初始化是非常重要的。换句话说，在虚表指针没有正确初始化之前，我们不能够去调用虚函数。 那么虚表指针在什么时候，或者说在什么地方初始化呢？
答案是在构造函数中进行虚表的创建和虚表指针的初始化。 还记得构造函数的调用顺序吗，在构造子类对象时，要先调用父类的构造函数，此时编译器只 “ 看到了 ” 父类，并不知道后面是否后还有继承者，它初始化父类对象 的虚表 指针，该虚表指针指向父类 的虚表 。当执行子类的构造函数时，子类对象 的虚表 指针被初始化，指向自身 的虚表 。对于例 2-2 的程序来说，当 fish 类的 fh 对象构造完毕后，其内部 的虚表 指针也就被初始化为指向 fish 类 的虚表 。在类型转换后，调用 pAn->breathe() ，由于
pAn 实际指向的是 fish 类的对象，该对象内部 的虚表 指针指向的是 fish 类 的虚表 ，因此最终调用的是 fish 类的 breathe() 函数。
要注意：对于虚函数调用来说， 每一个对象内部都有一个虚表指针，该虚表指针被初始化为本类 的虚表 。 所以在程序中，不管你的对象类型 如何 转换，但该对象内部 的虚表 指针是固定的，所以呢，才能实现动态的对象函数调用，这就是 C++ 多态性实现的原理。
总结（基类有虚函数）：
1. 每一个类都有虚表。
2. 虚表可以继承，如果子类没有重写虚函数，那么子类虚表中仍然会有该函数的地址，只不过这个地址指向的是基类的虚函数实现。如果基类有 3 个虚函数，那么基类 的虚表 中就有三项（虚函数地址），派生类也会有虚表，至少有三项，如果重写了相应的虚函数，那么虚表 中的 地址就会改变，指向自身的虚函数实现。如果派生类有自己的虚函数，那么虚表中就会添加该项。
3. 派生类 的虚表 中虚函数地址的排列顺序和基类 的虚表 中虚函数地址排列顺序相同。
这就是 C++ 中的 多态性。当 C++ 编译器 在 编译的时候，发现 animal 类的 breathe() 函数是虚函数，这个时候 C++ 就会采用迟绑定（ late binding ）技术。也就是编译时并不确定具体调用的函数，而是在运行时，依据对象的类型（在程序中，我们传递的 fish 类对象的地址）来确认调用的是 哪一个函数，这种能力就叫做 C++ 的多态性。我们没有在 breathe() 函数前加 virtual 关键字时， C++ 编译器 在编译时就确定了哪个函数被调用，这叫做早期绑定（ early
binding ）。
C++ 的多态性是通过迟绑定技术来实现的。
C++ 的多态性用一句话概括就是：在基类的函数前加上 virtual 关键字，在派生类中重写该函数，运行时将会根据对象的实际类型来调用相应的函数。如果对象类型是派生类，就调用派生类的函数；如果对象类型是基类，就调用基类的函数。
虚函数是在基类中定义的，目的是不确定它的派生类的具体行为。例：
定义一个基类： class Animal// 动物。它的函数为 breathe()// 呼吸。
再定义一个类 class Fish// 鱼 。它的函数也为 breathe()
再定义一个类 class Sheep // 羊。它的函数也为 breathe()
为了简化代码，将 Fish,Sheep 定义成基类 Animal 的派生类。
然而 Fish 与 Sheep 的 breathe 不一样，一个是在水中通过水来呼吸，一个是直接呼吸空气。所以基类不能确定该 如何 定义 breathe ，所以在基类中只定义了一个 virtual breathe, 它是一个空的虚函数。具本的函数在子类中分别定义。程序一般运行时，找到类，如果它有基类，再找它的基类，最后运行的是基类 中的 函数，这时，它在基类中找到的是 virtual 标识的函数，它就会再回到子类中找同名函数。派生类也叫子类。基类也叫父类。这就是虚函数的产生，和类的多态性（ breathe ）的体现。
这里的多态性是指类的多态性。
函 数的多态性是指一个函数被定义成多个不同参数的函数，它们一般被存在头文件中，当你调用这个函数，针对不同的参数，就会调用不同的同名函数。 例： Rect （） // 矩形。它的参数可以是两个坐标点（ point ， point) 也可能是四个坐标 (x1,y1,x2,y2) 这叫函数的多态性与函数的重 载。
类的多态性，是指用虚函数和延迟绑定来实现的。函数的多态性是函数的重载。
一般情况下（没有涉及 virtual 函数），当我们用一个指针 / 引用调用一个函数的时候，被调用的函数是取决于这个指针 / 引用的类型。即如果这个指针 / 引用是基类对象的指针 / 引用就调用基类的方法；如果指针 / 引用是派生类对象的指针 / 引用就调用派生类的方法，当然如果派生类中没有此方法，就会向上到基类里面去寻找相应的方法。这些调用在编译阶段就确定了。
当设计到多态性的时候，采用了虚函数和动态绑定，此时的调用就不会在编译时候确定而是在运行时确定。不在单独考虑指针 / 引用的类型而是看指针 / 引用的对象的类型来判断函数的调用，根据对象中虚指针指向 的虚表中的 函数的地址来确定调用哪个函数。
二、关于多态性的一些问题：
B b;
A *pa = &b;//A为基类，B为子类
pa-> foo();//foo()为虚函数
pa-> foo()会被编译为 (*pa-> vptr[1])(pa)；其中参数pa为this指针
pa的类型为A * ,应该只能访问A的成员
请问pa是怎样在虚函数里面访问B的成员的？
在进行虚函数调用时，其参数类型为foo(B * const this,...)
而实际传给该函数的为父类类型指针pa，所以编译器会进行隐式的
转换，即(B*)pa,因此在函数内部pa可以访问到B的成员。
三、用C语言实现多态（实际上就是struct内的一个函数指针）：
下面是转载
最近一直喜欢浏览国外网站,感觉收获很多,所以我跟苞谷说,看中文网站是无奇不有,看外文网站才知道世界之大.Polymorphism in C是我摘抄+修改+体会+翻译过来的好东东.有助于理解多态.
多态是什么?就是我们调用一个公共接口(相同函数名字)时,根据调用者的类型调用不同的函数,看过我之前写的C++向C的转化的人其实知道,函数名字相同只是我们肉眼看见的相同,编译器优化后,意味函数所属的class不一样,函数名字也要变化,显然函数的入口地址都是不一样的.C++中的RTTI和dynamic binding就是做这个事情.当然C也可以实现,C是C++的鼻祖嘛.
这个图中的Structs就是相当于一个class,所有有个class-like,然后每个structs里面有一个公共方法method,这个公共方法就在Common Interface里面,调用者调用这个method不用管它能否调到它想要的那个method,在C++中,可以让你的类型同你这个method绑定在一起,所以很方便,调用者直接call这个method就能call到你想用的那个方法.
其实多态就是函数指针实现的,因为C也有指针,C也可以做到.
/*file:Poly.h*/
#ifndef _POLY_H
#define _POLY_H
struct POLY_STRUCT
{
void (*poly)( ); // 多态函数,common interface
};
/* 初始化一个类(相当于),然后把这个公共函数的具体实现跟类型绑一起 */
struct POLY_STRUCT *InitPoly( void (*poly)() );
/* 释放一个类(相当于析构函数)*/
void DestroyPoly( struct POLY_STRUCT *poly );
#endif
/*file:Poly.c*/
struct POLY_STRUCT *InitPoly( void (*poly)() )
{
struct POLY_STRUCT *result = (struct POLY_STRUCT*)
malloc( sizeof( struct POLY_STRUCT ) );
if(result != NULL)
result->poly = poly;
return result;
}
void DestroyPoly( struct POLY_STRUCT *poly ){ if(poly != NULL) free(poly); }
/*file:main.c*/
/*下面是两个用父类指针表示的两个子类对象*/
struct POLY_STRUCT* example_poly1;
struct POLY_STRUCT* example_poly2;
/*定义两个函数,代表这两个子类中common interface的不同实现*/
void poly_example1_method(){printf("EXAMPLE1/n");}
void poly_example2_method(){printf("EXAMPLE2/n");}
int main(int argc, char *argv[])
{
example_poly1 = InitPoly(poly_example1_method);
example_poly2 = InitPoly(poly_example2_method);
/*父类指针调用相同的函数,但是结果呢?不一样*/
(*(example_poly1->poly))();
(*(example_poly2->poly))();
DestroyPoly(example_poly1);
DestroyPoly(example_poly2);
system("PAUSE");
return 0;
}
结果:
EXAMPLE1
EXAMPLE2
结论就是,函数指针导致了多态,它付出的代价就是程序机制的复杂性和不必要的代码开销,它的优点就是,将俗点就是呈现一致的函数名给我们(实际上编译时这个名字还是要变化),因为一致性,所以重用性和扩展性也更好了.
我喜欢那句话:优化性和可扩展性需要我们去平衡.这里也是.
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 