下载文档原格式
虚函数原理虚函数是 C++ 中一个非常重要的特性，它为面向对象编程提供了很强的支持。
虚函数的实现原理是通过虚函数表实现的，本文将介绍虚函数的概念、使用方法以及实现原理。
一、虚函数概念虚函数是指在基类中使用 virtual 关键字声明的成员函数，它的作用是允许在子类中对该函数进行覆盖。
具体来说，虚函数允许在子类中定义一个与基类中同名的函数，当使用子类对象调用该函数时，程序会动态的选择调用子类中的函数。
虚函数的语法如下：```class Base {public:virtual void foo();};```虚函数可以被重写（覆盖），也可以被继承，但是不能被 static 和 friend 修饰。
二、虚函数的使用使用虚函数需要满足一下条件：1.虚函数必须在公有的类成员函数列表中声明，并在类声明的内部定义。
2.虚函数必须在基类和派生类中以相同的参数列表进行定义。
下面是一个使用虚函数的简单例子：class Square: public Shape {public:Square(double s) : side(s) {}double getArea() { return side * side; }Shape 是一个基类，Square 是它的一个派生类，Square 中重写了 getArea() 函数，计算正方形的面积。
虚函数的实现原理是通过虚函数表实现的。
虚函数表是一个指针数组，存储了每个类中的虚函数指针。
当对象被创建时，会在其内存空间中创建一个指向虚函数表的指针，这个指针通常称为虚函数表指针（vptr），虚函数的调用就是通过这个指针完成的。
每个含有虚函数的类都有一个独立的虚函数表，虚函数表智能在类的第一个对象中存储，它包含了该类中所有虚函数的地址。
在派生类中，虚函数表通常继承自它的直接基类，并在此基础上添加或修改虚函数的地址。
这样如果在派生类对象中调用虚函数时，程序会先获得对象的虚函数表指针，然后通过该指针找到对应的虚函数地址来执行函数。
虚析构函数的调用顺序在C++中，虚析构函数是一种特殊的析构函数，它可以在派生类对象被销毁时自动调用基类的析构函数。
虚析构函数的调用顺序对于程序的正确性和性能有着重要的影响。
本文将从类的继承关系、虚函数表和虚析构函数的实现等方面，探讨虚析构函数的调用顺序。
一、类的继承关系在C++中，类的继承关系是通过派生类继承基类的成员变量和成员函数来实现的。
当派生类对象被销毁时，它的析构函数会被自动调用。
如果派生类没有定义自己的析构函数，编译器会自动生成一个默认的析构函数。
这个默认的析构函数会自动调用基类的析构函数，以确保基类的资源得到正确的释放。
二、虚函数表在C++中，虚函数表是一种用于实现多态的机制。
每个类都有一个虚函数表，其中存储了该类的虚函数的地址。
当一个对象被创建时，它会被赋予一个指向该类的虚函数表的指针。
当调用一个虚函数时，程序会根据该对象的虚函数表指针找到该函数的地址，并调用该函数。
三、虚析构函数的实现虚析构函数的实现是通过在虚函数表中添加一个指向析构函数的指针来实现的。
当一个派生类对象被销毁时，程序会先调用派生类的析构函数，然后再调用基类的析构函数。
这是因为派生类的析构函数中会自动调用基类的析构函数，以确保基类的资源得到正确的释放。
四、虚析构函数的调用顺序是从派生类到基类的顺序。
当一个派生类对象被销毁时，程序会先调用派生类的析构函数，然后再调用基类的析构函数。
这是因为派生类的析构函数中会自动调用基类的析构函数，以确保基类的资源得到正确的释放。
总结虚析构函数的调用顺序对于程序的正确性和性能有着重要的影响。
在C++中，虚析构函数的调用顺序是从派生类到基类的顺序。
这是因为派生类的析构函数中会自动调用基类的析构函数，以确保基类的资源得到正确的释放。
在编写程序时，我们应该注意虚析构函数的调用顺序，以确保程序的正确性和性能。
虚函数的实现原理虚函数是C++中的一种特殊函数，它允许派生类重写基类的同名函数，并根据对象的实际类型调用相应的函数。
虚函数的实现原理涉及到虚函数表（vtable）和虚函数指针（vpointer）两个重要的概念。
在C++中，每个包含虚函数的类都会生成一个与之对应的虚函数表（vtable）。
虚函数表是一个以函数指针为元素的数组，用于存储类的虚函数地址。
虚函数表中的每个元素都对应着类的一个虚函数，其中存储着该虚函数的地址。
虚函数表通常位于类的内存布局最前面的位置。
当一个类被定义为包含虚函数时，编译器会自动生成一个隐藏的虚函数指针（vpointer）并将它添加到类的内存布局中。
这个虚函数指针被添加到每一个类的对象中，并指向该对象对应的虚函数表。
通过虚函数指针，程序能够在运行时根据对象的实际类型找到正确的虚函数表，并调用相应的虚函数。
当派生类重写基类的虚函数时，它会生成一个新的函数地址并将其存储到自己对应的虚函数表中。
在派生类的虚函数表中，只有被重写的虚函数所对应的表项会被替换为新的函数地址，其它虚函数的表项仍然指向基类的虚函数地址。
这样，当通过派生类的对象调用虚函数时，程序会根据对象的实际类型找到对应的虚函数表，并调用正确的虚函数。
虚函数的实现原理可以通过以下示例代码进行说明：cpp#include <iostream>class Base {public:virtual void print() {std::cout << "Base::print()" << std::endl;}};class Derived : public Base {public:void print() override {std::cout << "Derived::print()" << std::endl;}};int main() {Base* base = new Derived();base->print(); 输出"Derived::print()"delete base;return 0;}在上述代码中，Base类包含一个虚函数print()，而Derived类重写了这个虚函数。
C++中的封装、继承、多态理解封装(encapsulation)：就是将抽象得到的数据和⾏为(或功能)相结合，形成⼀个有机的整体，也就是将数据与操作数据的源代码进⾏有机的结合，形成”类”，其中数据和函数都是类的成员。
封装的⽬的是增强安全性和简化编程，使⽤者不必了解具体的实现细节，⽽只是要通过外部接⼝，特定的访问权限来使⽤类的成员。
封装可以隐藏实现细节，使得代码模块化。
继承(inheritance)：C++通过类派⽣机制来⽀持继承。
被继承的类型称为基类或超类，新产⽣的类为派⽣类或⼦类。
保持已有类的特性⽽构造新类的过程称为继承。
在已有类的基础上新增⾃⼰的特性⽽产⽣新类的过程称为派⽣。
继承和派⽣的⽬的是保持已有类的特性并构造新类。
继承的⽬的：实现代码重⽤。
派⽣的⽬的：实现代码扩充。
三种继承⽅式：public、protected、private。
继承时的构造函数：(1)、基类的构造函数不能被继承，派⽣类中需要声明⾃⼰的构造函数；(2)、声明构造函数时，只需要对本类中新增成员进⾏初始化，对继承来的基类成员的初始化，⾃动调⽤基类构造函数完成；(3)、派⽣类的构造函数需要给基类的构造函数传递参数；(4)、单⼀继承时的构造函数：派⽣类名::派⽣类名(基类所需的形参，本类成员所需的形参):基类名(参数表) {本类成员初始化赋值语句；}；(5)、当基类中声明有默认形式的构造函数或未声明构造函数时，派⽣类构造函数可以不向基类构造函数传递参数；(6)、若基类中未声明构造函数，派⽣类中也可以不声明，全采⽤缺省形式构造函数；(7)、当基类声明有带形参的构造函数时，派⽣类也应声明带形参的构造函数，并将参数传递给基类构造函数；(8)、构造函数的调⽤次序：A、调⽤基类构造函数，调⽤顺序按照它们被继承时声明的顺序(从左向右)；B、调⽤成员对象的构造函数，调⽤顺序按照它们在类中的声明的顺序；C、派⽣类的构造函数体中的内容。
继承时的析构函数：(1)、析构函数也不被继承，派⽣类⾃⾏声明；(2)、声明⽅法与⼀般(⽆继承关系时)类的析构函数相同；(3)、不需要显⽰地调⽤基类的析构函数，系统会⾃动隐式调⽤；(4)、析构函数的调⽤次序与构造函数相反。
C++在单继承、多继承、虚继承时，构造函数、复制构造函数、赋值操作符、析构函数的执⾏顺序和执⾏内容⼀、本⽂⽬的与说明1. 本⽂⽬的：理清在各种继承时，构造函数、复制构造函数、赋值操作符、析构函数的执⾏顺序和执⾏内容。
2. 说明：虽然复制构造函数属于构造函数的⼀种，有共同的地⽅，但是也具有⼀定的特殊性，所以在总结它的性质时将它单独列出来了。
3. 单继承、多继承、虚继承，既然都属于继承，那么虽然有⼀定的区别，但还是相同点⽐较多。
如果放在⼀块讲，但为了将内容制作成递进的，就分开了，对相同点进⾏重复，（⼤量的复制粘贴哈），但在不同点进⾏了标注。
注意：三块内容是逐步递进的如果你懂虚函数，那么单继承和多继承那块你就可以不看；如果你懂多继承，那单继承你就不要看了，⾄于虚继承就等你懂虚继承再回来看吧；如果你只懂单继承，那你就只看单继承就好。
⼆、基本知识1. 对于⼀个空类，例如：class EmptyClass{};虽然你没有声明任何函数，但是编译器会⾃动为你提供上⾯这四个⽅法。
class EmptyClass {public:EmptyClass(); // 默认构造函数EmptyClass(const EmptyClass &rhs); // 复制构造函数~EmptyClass(); // 析构函数EmptyClass& operator=(const EmptyClass &rhs); // 赋值运算符}对于这四个⽅法的任何⼀个，你的类如果没有声明，那么编译器就会⾃动为你对应的提供⼀个默认的（注意合成默认构造函数是⽤于没有编写构造函数编译器才会合成默认构造函数，其中复制构造函数也是构造函数）。
（在《C++ primer》中，这个编译器⾃动提供的版本叫做“合成的***”，例如合成的复制构造函数）当然如果你显式声明了，编译器就不会再提供相应的⽅法。
2. 合成的默认构造函数执⾏内容：如果有⽗类，就先调⽤⽗类的默认构造函数。
C++虚函数及虚函数表解析虚函数的定义： 虚函数必须是类的⾮静态成员函数（且⾮构造函数），其访问权限是public（可以定义为private or proteceted，但是对于多态来说，没有意义。
），在基类的类定义中定义虚函数的⼀般形式： virtual 函数返回值类型虚函数名（形参表） { 函数体 } 虚函数的作⽤是实现动态联编，也就是在程序的运⾏阶段动态地选择合适的成员函数，在定义了虚函数后， 可以在基类的派⽣类中对虚函数重新定义（形式也是：virtual 函数返回值类型虚函数名（形参表）{ 函数体 }），在派⽣类中重新定义的函数应与虚函数具有相同的形参个数和形参类型。
以实现统⼀的接⼝，不同定义过程。
如果在派⽣类中没有对虚函数重新定义，则它继承其基类的虚函数。
当程序发现虚函数名前的关键字virtual后，会⾃动将其作为动态联编处理，即在程序运⾏时动态地选择合适的成员函数。
实现动态联编需要三个条件： 1、必须把需要动态联编的⾏为定义为类的公共属性的虚函数。
2、类之间存在⼦类型关系，⼀般表现为⼀个类从另⼀个类公有派⽣⽽来。
3、必须先使⽤基类指针指向⼦类型的对象，然后直接或者间接使⽤基类指针调⽤虚函数。
定义虚函数的限制： （1）⾮类的成员函数不能定义为虚函数，类的成员函数中静态成员函数和构造函数也不能定义为虚函数，但可以将析构函数定义为虚函数。
实际上，优秀的程序员常常把基类的析构函数定义为虚函数。
因为，将基类的析构函数定义为虚函数后，当利⽤delete删除⼀个指向派⽣类定义的对象指针时，系统会调⽤相应的类的析构函数。
⽽不将析构函数定义为虚函数时，只调⽤基类的析构函数。
（2）只需要在声明函数的类体中使⽤关键字“virtual”将函数声明为虚函数，⽽定义函数时不需要使⽤关键字“virtual”。
（3）如果声明了某个成员函数为虚函数，则在该类中不能出现和这个成员函数同名并且返回值、参数个数、参数类型都相同的⾮虚函数。
C++中虚函数工作原理和(虚)继承类的内存占用大小计算一、虚函数的工作原理虚函数的实现要求对象携带额外的信息，这些信息用于在运行时确定该对象应该调用哪一个虚函数。
典型情况下，这一信息具有一种被称为vptr（virtual table pointer，虚函数表指针）的指针的形式。
vptr 指向一个被称为vtbl（virtual table，虚函数表）的函数指针数组，每一个包含虚函数的类都关联到vtbl。
当一个对象调用了虚函数，实际的被调用函数通过下面的步骤确定：找到对象的vptr 指向的vtbl，然后在vtbl 中寻找合适的函数指针。
虚拟函数的地址翻译取决于对象的内存地址，而不取决于数据类型(编译器对函数调用的合法性检查取决于数据类型)。
如果类定义了虚函数，该类及其派生类就要生成一张虚拟函数表，即vtable。
而在类的对象地址空间中存储一个该虚表的入口，占4个字节，这个入口地址是在构造对象时由编译器写入的。
所以，由于对象的内存空间包含了虚表入口，编译器能够由这个入口找到恰当的虚函数，这个函数的地址不再由数据类型决定了。
故对于一个父类的对象指针，调用虚拟函数，如果给他赋父类对象的指针，那么他就调用父类中的函数，如果给他赋子类对象的指针，他就调用子类中的函数(取决于对象的内存地址)。
虚函数需要注意的大概就是这些个地方了，之前在More effective C++上好像也有见过，不过这次在Visual C++权威剖析这本书中有了更直白的认识，这本书名字很牛逼，看看内容也就那么回事，感觉名不副实，不过说起来也是有其独到之处的，否则也没必要出这种书了。
每当创建一个包含有虚函数的类或从包含有虚函数的类派生一个类时，编译器就会为这个类创建一个虚函数表（VTABLE）保存该类所有虚函数的地址，其实这个VTABLE的作用就是保存自己类中所有虚函数的地址，可以把VTABLE形象地看成一个函数指针数组，这个数组的每个元素存放的就是虚函数的地址。
《C++程序设计》课程标准一、课程定位和课程设计《C++程序设计》课程是计算机类专业群的一门基础课程，是从事计算机程序设计的入门课程，同时也是培养计算机程序设计基础能力与学习面向对象方法的重要课程。
本课程始终以技术的发展、企业对能力的要求、创新能力的提高为设计的根本依据。
课程教学的核心内容是工作内容和工作过程所要求的知识、技术和能力；教学过程严格遵循工作过程，由易到难、由浅到深、由简到繁、循序渐进的进行；本课程的设计参考职业资格和能力水平考试大纲。
课程教学使学生能综合全面可持续的发展。
二、职业能力要求通过本课程的教学，学生应达到如下职业能力目标：●能熟练应用VC++集成环境设计和调试C++语言程序。
●能在程序设计过程中运用C++语言数据类型、运算符、基本语句、数组、函数、编译预处理命令等基本知识，能初步运用指针、结构体、共用体、枚举类型、文件等基本知识。
●能用C++语言设计解决简单实际问题的程序，并能完成简单程序的测试。
三、课程教学实施基本理念1. 以现代教育模式为中心，突出教师的主导作用和学生的主体地位2. 注重学生的素质教育和能力培养3. 注重与时代的接轨4. 运用现代教学手段四、课程目标（一）知识目标通过《C++语言程序设计》课程的教学，使学生系统地掌握C语言的基本开发要求，掌握C++语言数据类型、结构化程序设计方法，数组及函数的使用，指针等使用规则等。
（二）能力目标C++语言程序设计的课程开设是从学生的角度出发，注重培养学生良好的动手实践习惯，注重培养学生严谨的行事风格，尤其注重挖掘学生的潜质，注重培养与社会接轨，培养学生具有踏实工作作风，良好的观察和思考能力强以及团队合作能力。
五、课程内容标准1）C++简单程序设计——C++语言概述了解C++语言的发展历史、特点，熟练掌握简单的C++程序的组成与书写格式，会使用C++程序的设计工具、开发过程。
重点：C++程序设计过程、组成与书写格式。
难点：C++程序特点和组成。
C++ 虚函数表解析前言 C++中的虚函数的作用主要是实现了多态的机制。
关于多态，简而言之就是用父类型别的指针 指向其子类的实例，然后通过父类的指针调用实际子类的成员函数。
这种技术可以让父类的指针 有“多种形态”，这是一种泛型技术。
所谓泛型技术，说白了就是试图使用不变的代码来实现可 变的算法。
比如：模板技术，RTTI 技术，虚函数技术，要么是试图做到在编译时决议，要么试图 做到运行时决议。
关于虚函数的使用方法，我在这里不做过多的阐述。
大家可以看看相关的 C++的书籍。
在这篇 文章中，我只想从虚函数的实现机制上面为大家 一个清晰的剖析。
当然，相同的文章在网上也出现过一些了，但我总感觉这些文章不是很容易阅读，大段大段的 代码，没有图片，没有详细的说明，没有比较，没有举一反三。
不利于学习和阅读，所以这是我 想写下这篇文章的原因。
也希望大家多给我提意见。
言归正传，让我们一起进入虚函数的世界。
虚函数表 对 C++ 了解的人都应该知道虚函数 （Virtual Function） 是通过一张虚函数表 （Virtual Table） 来实现的。
简称为 V-Table。
在这个表中，主要是一个类的虚函数的地址表，这张表解决了继承、 覆盖的问题，保证其容真实反应实际的函数。
这样，在有虚函数的类的实例中这个表被分配在了 这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由 为重要了，它就像一个地图一样，指明了实际所应该调用的函数。
这里我们着重看一下这张虚函数表。
C++的编译器应该是保证虚函数表的指针存在于对象实例 中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承 的情况下） 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指 。
针，并调用相应的函数。
听我扯了那么多，我可以感觉出来你现在可能比以前更加晕头转向了。
没关系，下面就是实 际的例子，相信聪明的你一看就明白了。
假设我们有这样的一个类： 以下是引用片段： class Base { public: virtual void f() { cout << "Base::f" << endl; } virtual void g() { cout << "Base::g" << endl; } virtual void h() { cout << "Base::h" << endl; } };按照上面的说法，我们可以通过 Base 的实例来得到虚函数表。
下面是实际例程： 以下是引用片段： typedef void(*Fun)(void);Base b; Fun pFun = NULL; cout << "指向虚函数表的指针的地址：" << (int*)(&b) << endl; cout << "虚函数表 — 指向第一个函数的指针的地址：" << (int*)*(int*)(&b) << endl; // Invoke the first virtual function pFun = (Fun)*((int*)*(int*)(&b)); pFun(); 实际运行经果如下：(Windows XP+VS2003, Linux 2.6.22 + GCC 4.1.3)以下是引用片段： 虚函数表地址：0012FED4 虚函数表 — 第一个函数地址：0044F148 Base::f通过这个示例，我们可以看到，我们可以通过强行把&b 转成 int *，取得虚函数表的地址，然 后，再次取址就可以得到第一个虚函数的地址了，也就是 Base::f()，这在上面的程序中得到了 验证（把 int* 强制转成了函数指针） 。
通过这个示例，我们就可以知道如果要调用 Base::g()和 Base::h()，其代码如下： 以下是引用片段： (Fun)*((int*)*(int*)(&b)+0); (Fun)*((int*)*(int*)(&b)+1); (Fun)*((int*)*(int*)(&b)+2); 个图解释一下。
如下所示： // Base::f() // Base::g() // Base::h()这个时候你应该懂了吧。
什么？还是有点晕。
也是，这样的代码看着太乱了。
没问题，让我画注意：在上面这个图中，我在虚函数表的最后多加了一个结点，这是虚函数表的结束结点，就 像字符串的结束符“\0”一样，其标志了虚函数表的结束。
这个结束标志的值在不同的编译器下 是不同的。
在 WinXP+VS2003下，这个值是 NULL。
而在 Ubuntu 7.10 + Linux 2.6.22 + GCC 4.1.3 下，这个值是如果1，表示还有下一个虚函数表，如果值是0，表示是最后一个虚函数表。
下面，我将分别说明“无覆盖”和“有覆盖”时的虚函数表的样子。
没有覆盖父类的虚函数是 毫无意义的。
我之所以要讲述没有覆盖的情况，主要目的是为了给一个对比。
在比较之下，我们 可以更加清楚地知道其内部的具体实现。
一般继承（无虚函数覆盖） 下面，再让我们来看看继承时的虚函数表是什么样的。
假设有如下所示的一个继承关系：请注意，在这个继承关系中，子类没有重载任何父类的函数。
那么，在派生类的实例中，其虚 函数表如下所示： 对于实例：Derive d; 的虚函数表如下：我们可以看到下面几点： 1）虚函数按照其声明顺序放于表中。
2）父类的虚函数在子类的虚函数前面。
我相信聪明的你一定可以参考前面的那个程序，来编写一段程序来验证。
一般继承（有虚函数覆盖） 覆盖父类的虚函数是很显然的事情，不然，虚函数就变得毫无意义。
下面，我们来看一下，如 果子类中有虚函数重载了父类的虚函数，会是一个什么样子？假设，我们有下面这样的一个继承 关系。
为了让大家看到被继承过后的效果，在这个类的设计中，我只覆盖了父类的一个函数：f()。
那么，对于派生类的实例，其虚函数表会是下面的一个样子：我们从表中可以看到下面几点， 1）覆盖的 f()函数被放到了虚表中原来父类虚函数的位置。
2）没有被覆盖的函数依旧。
这样，我们就可以看到对于下面这样的程序， 以下是引用片段： Base *b = new Derive(); b->f(); 由 b 所指的内存中的虚函数表的 f()的位置已经被 Derive::f()函数地址所取代，于是在实际 调用发生时，是 Derive::f()被调用了。
这就实现了多态。
多重继承（无虚函数覆盖） 下面，再让我们来看看多重继承中的情况，假设有下面这样一个类的继承关系。
注意：子类并 没有覆盖父类的函数。
对于子类实例中的虚函数表，是下面这个样子：我们可以看到： 1） 每个父类都有自己的虚表。
2） 子类的成员函数被放到了第一个父类的表中。
（所谓的第一个父类是按照声明顺序来判断 的） 这样做就是为了解决不同的父类类型的指针指向同一个子类实例，而能够调用到实际的函数。
多重继承（有虚函数覆盖） 下面我们再来看看，如果发生虚函数覆盖的情况。
下图中，我们在子类中覆盖了父类的 f()函数。
下面是对于子类实例中的虚函数表的图：我们可以看见，三个父类虚函数表中的 f()的位置被替换成了子类的函数指针。
这样，我们就 可以任一静态类型的父类来指向子类，并调用子类的 f()了。
如： 以下是引用片段： Derive d; Base1 *b1 = &d; Base2 *b2 = &d; Base3 *b3 = &d; b1->f(); //Derive::f() b2->f(); //Derive::f() b3->f(); //Derive::f() b1->g(); //Base1::g() b2->g(); //Base2::g() b3->g(); //Base3::g() 安全性 每次写 C++的文章，总免不了要批判一下 C++。
这篇文章也不例外。
通过上面的讲述，相信我 们对虚函数表有一个比较细致的了解了。
水可载舟，亦可覆舟。
下面，让我们来看看我们可以用 虚函数表来干点什么坏事吧。
一、通过父类型的指针访问子类自己的虚函数 我们知道，子类没有重载父类的虚函数是一件毫无意义的事情。
因为多态也是要基于函数重载 的。
虽然在上面的图中我们可以看到 Base1的虚表中有 Derive 的虚函数，但我们根本不可能使用 下面的语句来调用子类的自有虚函数： 以下是引用片段： Base1 *b1 = new Derive(); b1->f1(); //编译出错 任何妄图使用父类指针想调用子类中的未覆盖父类的成员函数的行为都会被编译器视为非法， 所以，这样的程序根本无法编译通过。
但在运行时，我们可以通过指针的方式访问虚函数表来达 到违反 C++语义的行为。
（关于这方面的尝试， 通过阅读后面附录的代码， 相信你可以做到这一点） 二、访问 non-public 的虚函数另外，如果父类的虚函数是 private 或是 protected 的，但这些非 public 的虚函数同样会存 在于虚函数表中， 所以， 我们同样可以使用访问虚函数表的方式来访问这些 non-public 的虚函数， 这是很容易做到的。
如： 以下是引用片段： class Base { private: virtual void f() { cout << "Base::f" << endl; } }; class Derive : public Base{ }; typedef void(*Fun)(void); void main() { Derive d; Fun } 结束语 C++这门语言是一门 Magic 的语言，对于程序员来说，我们似乎永远摸不清楚这门语言背着我 们在干了什么。
需要熟悉这门语言，我们就必需要了解 C++里面的那些东西，需要去了解 C++中那 些危险的东西。
不然，这是一种搬起石头砸自己脚的编程语言。
在文章束之前还是介绍一下自己吧。
我从事软件研发有十个年头了， 目前是软件开发技术主管， 技术方面，主攻 Unix/C/C++，比较喜欢网络上的技术，比如分布式计算，网格计算，P2P，Ajax 等一切和互联网相关的东西。
