虽然很难找到一本不讨论多态性的C++书籍或杂志，但是，大多数这类讨论使多态性和C++虚函数的使用看起来很难。我打算在这篇文章中通过从几个方面和结合一些例子使读者理解在C++中的虚函数实现技术。说明一点，写这篇文章只是想和大家交流学习经验因为本人学识浅薄，难免有一些错误和不足，希望大家批评和指正，在此深表感谢！
在类中，如果什么都没有，则类占用1个字节，一旦类中有其他的占用空间成员，则这1个字节就不在计算之内，如一个类只有一个int则占用4字节而不是5字节。
如果只有成员函数，则还是只占用1个字节，因为类函数不占用空间
虚函数因为存在一个虚函数表，需要4个字节，数据成员对象如果为指针则为4字节，注意有字节对齐，如果为13字节，则进位到16字节空间。
一、 基本概念
首先，C++通过虚函数实现多态."无论发送消息的对象属于什么类，它们均发送具有同一形式的消息，对消息的处理方式可能随接手消息的对象而变"的处理方式被称为多态性。"在某个基类上建立起来的类的层次构造中，可以对任何一个派生类的对象中的同名过程进行调用，而被调用的过程提供的处理可以随其所属的类而变。"虚函数首先是一种成员函数，它可以在该类的派生类中被重新定义并被赋予另外一种处理功能。
二、 虚函数的定义与派生类中的重定义
class 类名{
public:
virtual 成员函数说明；
}
class 类名：基类名{
public:
virtual 成员函数说明；
}
三、 虚函数在内存中的结构
1．我们先看一个例子：
#include "iostream.h"
#include "string.h"
class A {
public:
virtual void fun0() { cout << "A::fun0" << endl; }
};
int main(int argc, char* argv[])
{
A a;
cout << "Size of A = " << sizeof(a) << endl;
return 0;
}
结果如下：Size of A = 4
2．如果再添加一个虚函数：virtual void fun1() { cout << "A::fun" << endl;}
得到相同的结果。如果去掉函数前面的virtual修饰符
class A {
public:
void fun0() { cout << "A::fun0" << endl; }
};
int main(int argc, char* argv[])
{
A a;
cout << "Size of A = " << sizeof(a) << endl;
return 0;
}
结果如下：Size of A = 1
3．在看下面的结果：
class A {
public:
virtual void fun0() { cout << "A::fun0" << endl; }
int a;
int b;
};
int main(int argc, char* argv[])
{
A a;
cout << "Size of A = " << sizeof(a) << endl;
return 0;
}
结果如下：Size of A = 12
其实虚函数在内存中结构是这样的:
图一
在window2000下指针在内存中占4个字节，虚函数在一个虚函数表(VTABLE)中保存函数地址。在看下面例子。
class A {
public:
virtual void fun0() { cout << "A::fun0" << endl; }
virtual void fun1() { cout << "A::fun1" << endl; }
}；
int main(int argc, char* argv[])
{
A a;
cout << "Size of A = " << sizeof(a) << endl;
return 0;
}
结果如下：结果如下：
Size of A = 4
虚函数的内存结构如下，你也可以通过函数指针，先找到虚函数表(VTABLE),然后访问每个函数地址来验证这种结构，在国外网站作者是：Zeeshan Amjad写的"ATL on the Hood中有详细介绍"
图二
4．我们再来看看继承中虚函数的内存结构，先看下面的例子
class A {
public:
virtual void f() { }
};
class B {
public:
virtual void f() { }
};
class C {
public:
virtual void f() { }
};
class Drive : public A, public B, public C {
};
int main() {
Drive d;
cout << "Size is = " << sizeof(d) << endl;
return 0;
}
结果如下：Size is = 12 ，相信大家一看下面的结构图就会很清楚，
图三
5.我们再来看看用虚函数实现多态性，先看个例子：
class A {
public:
virtual void f() { cout << "A::f" << endl; }
};
class B :public A{
public:
virtual void f() { cout << "B::f" << endl;}
};
class C :public A {
public:
virtual void f() { cout << "C::f" << endl;}
};
class Drive : public C {
public:
virtual void f() { cout << "D::f" << endl;}
};
int main(int argc, char* argv[])
{
A a;
B b;
C c;
Drive d;
a.f();
b.f();
c.f();
d.f();
return 0;
}
结果：A::f
B::f
C::f
D::f
不用解释，相信大家一看就明白什么道理！注意：多态不是函数重载
6．用虚函数实现动态连接 在编译期间，C++编译器根据程序传递给函数的参数或者函数返回类型来决定程序使用那个函数，然后编译器用正确的的函数替换每次启动。这种基于编译器的替换被称为静态连接，他们在程序运行之前执行。另一方面，当程序执行多态性时，替换是在程序执行期进行的，这种运行期间替换被称为动态连接。如下例子：
class A{
public:
virtual void f(){cout << "A::f" << endl;};
};
class B:public A{
public:
virtual void f(){cout << "B::f" << endl;};
};
class C:public A{
public:
virtual void f(){cout << "C::f" << endl;};
};
void test(A *a){
a->f();
};
int main(int argc, char* argv[])
{
B *b=new B;
C *c=new C;
char choice;
do{
cout<<"type B for class B,C for class C:"<<endl;
cin>>choice;
if(choice==''b'')
test(b);
else if(choice==''c'')
test(c);
}while(1);
cout<<endl<<endl;
return 0;
}
在上面的例子中，如果把类A,B,C中的virtual修饰符去掉，看看打印的结果，然后再看下面一个例子想想两者的联系。如果把B和C中的virtual修饰符去掉，又会怎样，结果和没有去掉一样。
7．在基类中调用继承类的函数（如果此函数是虚函数才能如此） 还是先看例子：
class A {
public:
virtual void fun() {
cout << "A::fun" << endl;
}
void show() {
fun();
}
};
class B : public A {
public:
virtual void fun() {
cout << "B::fun" << endl;
}
};
int main() {
A a;
a.show();
return 0;
}
打印结果：A::fun
在6中的例子中，test(A *a)其实有一个继承类指针向基类指针隐式转化的过程。可以看出利用虚函数我们可以在基类调用继承类函数。但如果不是虚函数，继承类指针转化为基类指针后只可以调用基类函数。反之，如果基类指针向继承类指针转化的情况怎样，这只能进行显示转化，转化后的继承类指针可以调用基类和继承类指针。如下例子：
class A {
public:
void fun() {
cout << "A::fun" << endl;
}
};
class B : public A {
public:
void fun() {
cout << "B::fun" << endl;
}
void fun0() {
cout << "B::fun0" << endl;
}
};
int main() {
A *a=new A;
B *b=new B;
A *pa;
B *pb;
pb=static_cast<B *>(a); //基类指针向继承类指针进行显示转化
pb->fun0();
pb->fun();
return 0;
}
参考资料：
1.科学出版社 《C++程序设计》
2．Zeeshan Amjad 《ATL on the Hood》
补充（本人总结）：
class CA
{
public:
CA(void);
virtual void f(){int a = 10;}
virtual void g(){ }
private:
int c;
};
此时sizeof（CA） 等于8；
class CA
{
public:
CA(void);
virtual void f(){int a = 10;}
private:
int c;
};
此时sizeof（CA） 等于8；
class CA
{
public:
CA(void);
virtual void f(){int a = 10;}
private:
int c;
char ch;
};
此时sizeof（CA） 等于12；
class CA
{
public:
CA(void);
virtual void f(){int a = 10;}
private:
int c;
char ch1;
char ch2
};
此时sizeof（CA） 等于12；
class CA
{
public:
CA(void);
virtual void f(){int a = 10;}
private:
int c;
char ch1;
int d;
};
此时sizeof（CA） 等于16；
因为类的分布也要考虑字节对齐的机制
C++中的static关键字继承自C语言，包含两方面含义：静态存储和可见性控制。定义成静态类型的变量会被保存在全局数据区，定义成静态类型的变量或者函数只能在本编译单元内被访问到，这样在不同文件中定义同名的变量就不会发生重复定义错误了。C++中static的应用分为两个方面：一是用于普通的函数和变量，二是在类中的应用。
一、在普通函数和变量中的应用
1、静态全局变量
在全局变量前面加上static，该变量就成了一个静态全局变量。静态全局变量有如下特点：
1）、变量存储在全局数据区；
2）、变量会被自动初始化为0；
3）、静态全局变量在整个编译单元（整个文件）内都是可见的，而在文件之外是不可见的。
静态变量自动初始化为0的特性可以给程序开发带来某些便利，比如定义一个字符串数组为了保证字符结尾为'/0'需要遍历整个数组进行初始化，但是定义成静态的字符串数组会被自动填充为0，'/0'就是0，所以说利用这些特性可以增加程序的运行效率。对于当前编译单元内需要共享的全局变量可以设置为静态的，这样既不用担心在其他文件中有重名的问题又能满足要求。
如下代码展示了静态全局变量的特性：
view plain copy to clipboard print ?
// file1.cpp
#include <iostream>
using namespace std;
static int n = 1;
void fun2();
void fun1() {
cout << n << endl;
}
int main() {
fun1();
fun2();
return 1;
}
view plain copy to clipboard print ?
// file2.cpp
#include <iostream>
using namespace std;
extern int n;
void fun2() {
cout << n << endl;
}
分别编译两个文件，然后连接，出现错误，说找不到n，这就说明n只在file1.cpp中有效file2.cpp。现在将file2中的extern int n改为int n = 2，重新编译运行，将输出：1 2，这说明file1和file2分别用了自己文件中定义的n，这就是可见性控制。
2、静态局部变量
在函数体内定义一个局部变量，变量被存储在堆栈中，函数返回后堆栈被恢复变量就被释放了。但是静态局部变量和静态全局变量相同，都是保存在全局数据区，在没有被显式初始化的情况下也会被初始化为0，函数返回后仍然有效，函数重入后数据依然是上次的结果，这和全局变量有相同的效果，但是全局变量不只是属于函数本身，其他代码也能看到很容易破坏变量的内容，所以静态局部变量在某些需要保存函数运行状态的时候很有用。
例如：
view plaincopy to clipboardprint?
// file3.cpp
#include <iostream>
using namespace std;
void fun() {
static int n = 1;
cout << n << endl;
n++;
}
int main() {
fun();
fun();
fun();
return 1;
}
编译运行，结果将输出1 2 3，这说明函数每次调用n的值都被保存了下来。
3、静态函数
在函数定义前加上static就将函数定义为静态了，静态函数的可见性与静态全局变量相同，只在当前文件中有效，不能被其他文件看到。除了这些特点静态函数和其它函数没有什么区别，这一点也就是体现出了static关键字在控制可见性方面的用处。
view plain copy to clipboard print ?
// file4.cpp
#include <iostream>
using namespace std;
static void fun() {
cout << "fun" << endl;
}
view plain copy to clipboard print ?
// file5.cpp
void fun();
int main() {
fun();
}
单独编译这两个文件，连接成一个程序会出现错误：找不到fun()函数，将file4中fun函数定义中的static去掉就OK了。
二、在类中的应用
1、类中的静态成员变量
在类的成员变量声明前加上static，该变量就成为了类的静态成员变量，例如：
view plain copy to clipboard print ?
// file6.cpp
#include <iostream>
using namespace std;
class A {
int size;
public:
static int n;
};
int A::n = 1;
int main() {
A a, b;
A::n++;
cout << "A::n = " << A::n << endl;
cout << "a.n = " << a.n <<endl;
a.n++;
cout << "b.n = " << b.n << endl;
cout << "sizeof(A) = " << sizeof(A) << endl;
cout << "sizeof(a) = " << sizeof(a) << endl;
return 1;
}
编译运行，产生如下输出：
A::n = 2
a.n = 2
b.n = 3
sizeof(A) = 4
sizeof(a) = 4
可以看出类的静态成员变量是属于类本身的，而不是属于某个对象的，所有对象看到的n值都相同，然后看类A和对象a的尺寸，只有int的大小4，这说明静态成员变量和对象本身并不在同一个存储区域，实际上类的静态存成员变量和其他静态变量一样也是存储在全局数据区的，这个问题我在去麦石应聘笔试的时候曾经遇到过，再关注一下。
对静态成员变量的初始化可以采用如下形式：
<类型名> <类名>::<静态成员变量名> = <值>
对于静态成员变量的引用可以通过如下形式：
<类名>::<静态成员变量名> = <值>
<对象名>.<静态成员变量名>
类的静态成员变量的意义在于某些类可能存在所有对象公共的属性，这个时候就可以使用静态成员变量，不仅可以节省存储空间，而且当公共属性改变后所有对象都能看到，不需要再通知所有的对象。而且类的静态成员变量和普通成员变量一样都可以设置访问权限控制，比如设置成private，则该变量只能在类内部被调用。
2、类的静态成员函数
类的静态成员函数与静态成员变量一样，属于类而不属于对象。一般类的成员函数都有一个隐含的this指针当做参数，这样函数就可以访问对象的成员变量，但是静态成员函数没有这个参数，所以静态成员函数不能访问对象的成员变量，而只能访问其他静态成员。下面是使用静态成员函数的例子：
view plain copy to clipboard print ?
// file7.cpp
#include <iostream>
using namespace std;
class A {
int n;
static int m;
public:
void fun1() {
// 一般函数可以调用静态和非静态成员，无特殊限制
cout << n + m << endl;
fun2();
}
static void fun2() {
cout << m << endl;
// 错误：静态成员函数不能调用非静态成员
//cout << n << endl;
//fun1();
}
};
int main() {
A a;
A::fun2();
a.fun1();
a.fun2();
}
可以看出静态成员函数和静态成员变量的调用方式是相同的。
三、总结
C++语言当中有很多细节问题，熟练地在代码中应用这些可以大大的提高我们程序的健壮性和灵活性。最近在应聘工作，这些问题很容易被作为考题，在这里系统的总结一下。
class CA
{
public:
CA(void);
virtual void f(){int a = 10;}
private:
int c;
char ch;
};