C++面试常考点

C++中的重载、覆盖和隐藏的区分

今天看书遇到了C++中比较难缠的概念，就是重载、覆盖和隐藏。如果只要区分重载和覆盖，相信应该没有什么难度，并且它们的界限还是比较清晰的。现在加上了隐藏，初次看这些概念还真是不好区分。下面总结一下它们之间的区别： 

成员函数的 重载 的特征有以下4点： 
（1） 必需在相同的范围内，即在同一个类的内部； 
（2） 函数名称相同； 
（3） 函数的参数不相同； 
（4） virtual关键字可选，即可以加上也可以不加上，不影响重载的发生。 

覆盖是指派生类函数覆盖基类函数，它的特征有以下4点： 
（1）必需在不同的范围中，即分别在派生类和基类中； 
（2） 函数名称相同； 
（3） 参数也必需相同； 
（4） 基类函数必需有virtual关键字。 

而隐藏行为则必需符合以下两条规则： 
（1） 如果派生类的函数与基类的函数的名称相同，但是参数不同。此时，不管有无virtual关键字，基类的函数都会被派生类的同名函数隐藏； 
（2） 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。这个时候基类的同名函数也会被隐藏。 

下面Demo说明了覆盖和隐藏之间的区别 

覆盖例子： 

C++代码  

1. #include <iostream>  
2. #include <cstdlib>  
3.   
4. using namespace std;  
5.   
6. class a  
7. {  
8.   public :  
9.          void virtual hello()  
10.          {  
11.               cout<<"a hello()"<<endl;       
12.          }      
13.            
14.          void hello(int i)  
15.          {  
16.               cout<<"a.hello(i)"<<i<<endl;       
17.          }  
18.            
19.            
20. };  
21.   
22. class b: public a  
23. {  
24.   public:  
25.          void hello()   
26.          {  
27.               cout<<"b hello()"<<endl;      
28.          }     
29.          void hello(int i) const  
30.          {  
31.               cout<<"b.hello(i)"<<i<<endl;       
32.          }   
33. };  
34.   
35. int main(int argc,char * args[])  
36. {  
37.     {  
38.          a *aptr=new b;  
39.          aptr->hello();  
40.            
41.          b* bptr=new b;  
42.          bptr->hello();  
43.            
44.          delete aptr;  
45.          delete bptr;  
46.     }  
47.       
48.     system("pause");  
49.     return EXIT_SUCCESS;      
50. }  

上面的例子是覆盖，由于基类a中和派生类b中的hello函数的签名完全相同，而且基类a中有virtual关键字，所以基类a中的hello函数被派生类b中的hello函数所覆盖，因此具有多态的特性（只有覆盖才具有多态的特征）。 

这段代码显示的结果为： 
 

稍微改动上述代码，得到下面的例子： 

C++代码  

1. #include <iostream>  
2. #include <cstdlib>  
3.   
4. using namespace std;  
5.   
6. class a  
7. {  
8.   public :  
9.          void hello()  
10.          {  
11.               cout<<"a hello()"<<endl;       
12.          }      
13.            
14.          void hello(int i)  
15.          {  
16.               cout<<"a.hello(i)"<<i<<endl;       
17.          }  
18.            
19.            
20. };  
21.   
22. class b: public a  
23. {  
24.   public:  
25.          void hello() const   
26.          {  
27.               cout<<"b hello()"<<endl;      
28.          }     
29.          void hello(int i) const  
30.          {  
31.               cout<<"b.hello(i)"<<i<<endl;       
32.          }   
33. };  
34.   
35. int main(int argc,char * args[])  
36. {  
37.     {  
38.          a *aptr=new b;  
39.          aptr->hello();  
40.            
41.          b* bptr=new b;  
42.          bptr->hello();  
43.            
44.          delete aptr;  
45.          delete bptr;  
46.     }  
47.       
48.     system("pause");  
49.     return EXIT_SUCCESS;      
50. }  

改动后代码运行的结果是： 
 

=====================================================================================

面向对象的三个基本特征是：封装、继承、多态。 
封装 
封装最好理解了。封装是面向对象的特征之一，是对象和类概念的主要特性。 

封装，也就是把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。 

继承 
面向对象编程 (OOP) 语言的一个主要功能就是“继承”。继承是指这样一种能力：它可以使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 


通过继承创建的新类称为“子类”或“派生类”。 


被继承的类称为“基类”、“父类”或“超类”。 


继承的过程，就是从一般到特殊的过程。 


要实现继承，可以通过“继承”（Inheritance）和“组合”（Composition）来实现。 


在某些 OOP 语言中，一个子类可以继承多个基类。但是一般情况下，一个子类只能有一个基类，要实现多重继承，可以通过多级继承来实现。 




继承概念的实现方式有三类：实现继承、接口继承和可视继承。 


Ø         实现继承是指使用基类的属性和方法而无需额外编码的能力； 


Ø         接口继承是指仅使用属性和方法的名称、但是子类必须提供实现的能力； 


Ø         可视继承是指子窗体（类）使用基窗体（类）的外观和实现代码的能力。 


在考虑使用继承时，有一点需要注意，那就是两个类之间的关系应该是“属于”关系。例如，Employee 是一个人，Manager 也是一个人，因此这两个类都可以继承 Person 类。但是 Leg 类却不能继承 Person 类，因为腿并不是一个人。 


抽象类仅定义将由子类创建的一般属性和方法，创建抽象类时，请使用关键字 Interface 而不是 Class。 


OO开发范式大致为：划分对象→抽象类→将类组织成为层次化结构(继承和合成) →用类与实例进行设计和实现几个阶段。 




多态 
多态性（polymorphisn）是允许你将父对象设置成为和一个或更多的他的子对象相等的技术，赋值之后，父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作。简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。 


实现多态，有二种方式，覆盖（override），重载（overload）。 


覆盖，是指子类重新定义父类的虚函数的做法。它是覆盖了一个方法并且对其重写，以求达到不同的作用。对我们来说最熟悉的覆盖就是对接口方法的实现，在接口中一般只是对方法进行了声明，而我们在实现时，就需要实现接口声明的所有方法。除了这个典型的用法以外，我们在继承中也可能会在子类覆盖父类中的方法。在覆盖要注意以下的几点： 
1、覆盖的方法的标志必须要和被覆盖的方法的标志完全匹配，才能达到覆盖的效果； 
2、覆盖的方法的返回值必须和被覆盖的方法的返回一致； 
3、覆盖的方法所抛出的异常必须和被覆盖方法的所抛出的异常一致，或者是其子类； 
4、被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。 



重载，是指允许存在多个同名函数，而这些函数的参数表不同（或许参数个数不同，或许参数类型不同，或许两者都不同）。它是指我们可以定义一些名称相同的方法，通过定义不同的输入参数来区分这些方法，然后再调用时，VM就会根据不同的参数样式，来选择合适的方法执行。在使用重载要注意以下的几点： 
1、在使用重载时只能通过不同的参数样式。例如，不同的参数类型，不同的参数个数，不同的参数顺序（当然，同一方法内的几个参数类型必须不一样，例如可以是fun(int,float)，但是不能为fun(int,int)）； 
2、不能通过访问权限、返回类型、抛出的异常进行重载； 
3、方法的异常类型和数目不会对重载造成影响； 
4、对于继承来说，如果某一方法在父类中是访问权限是priavte，那么就不能在子类对其进行重载，如果定义的话，也只是定义了一个新方法，而不会达到重载的效果。 



其实，重载的概念并不属于“面向对象编程”，重载的实现是：编译器根据函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数（至少对于编译器来说是这样的）。如，有两个同名函数：function func(p:integer):integer;和function func(p:string):integer;。那么编译器做过修饰后的函数名称可能是这样的：int_func、str_func。对于这两个函数的调用，在编译器间就已经确定了，是静态的（记住：是静态）。也就是说，它们的地址在编译期就绑定了（早绑定），因此，重载和多态无关！真正和多态相关的是“覆盖”。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态（记住：是动态！）的调用属于子类的该函数，这样的函数调用在编译期间是无法确定的（调用的子类的虚函数的地址无法给出）。因此，这样的函数地址是在运行期绑定的（晚邦定）。结论就是：重载只是一种语言特性，与多态无关，与面向对象也无关！引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚邦定，它就不是多态。” 


那么，多态的作用是什么呢？我们知道，封装可以隐藏实现细节，使得代码模块化；继承可以扩展已存在的代码模块（类）；它们的目的都是为了代码重用。而多态则是为了实现另一个目的??接口重用！多态的作用，就是为了类在继承和派生的时候，保证使用“家谱”中任一类的实例的某一属性时的正确调用。 

=================================================================================================

一、#include “filename.h”和#include 的区别
    #include “filename.h”是指编译器将从当前工作目录上开始查找此文件
    #include 是指编译器将从标准库目录中开始查找此文件
    二、头文件的作用
    加强安全检测
    通过头文件可能方便地调用库功能，而不必关心其实现方式
    三、* ， &修饰符的位置
    对于*和&修饰符，为了避免误解，最好将修饰符紧靠变量名
    四、if语句
    不要将布尔变量与任何值进行比较，那会很容易出错的。
    整形变量必须要有类型相同的值进行比较
    浮点变量最好少比点，就算要比也要有值进行限制
    指针变量要和NULL进行比较，不要和布尔型和整形比较
    五、const和#define的比较
    const有数据类型，#define没有数据类型
    个别编译器中const可以进行调试，#define不可以进行调试
    在类中定义常量有两种方式
    1、 在类在声明常量，但不赋值，在构造函数初始化表中进行赋值；
    2、 用枚举代替const常量。
    六、C++函数中值的传递方式
    有三种方式：值传递（Pass by value）、指针传递（Pass by pointer）、引用传递（Pass by reference）
    void fun（char c） //pass by value
    void fun（char *str） //pass by pointer
    void fun（char &str） //pass by reference
    如果输入参数是以值传递的话，最好使用引用传递代替，因为引用传递省去了临时对象的构造和析构
    函数的类型不能省略，就算没有也要加个void
    七、函数体中的指针或引用常量不能被返回
 
 Char *func(void)
{
char str[]=”Hello Word”;
//这个是不能被返回的，因为str是个指定变量，不是一般的值，函数结束后会被注销掉
return str;
}  
    函数体内的指针变量并不会随着函数的消亡而自动释放
    八、一个内存拷贝函数的实现体
 
 void *memcpy(void *pvTo,const void *pvFrom,size_t size)
{
assert((pvTo!=NULL)&&(pvFrom!=NULL));
byte *pbTo=(byte*)pvTo; //防止地址被改变
byte *pbFrom=(byte*)pvFrom;
while (size-- >0)
pbTo++ = pbForm++;
return pvTo;
}  
    九、内存的分配方式
    分配方式有三种，请记住，说不定那天去面试的时候就会有人问你这问题
    1、 静态存储区，是在程序编译时就已经分配好的，在整个运行期间都存在，如全局变量、常量。
    2、 栈上分配，函数内的局部变量就是从这分配的，但分配的内存容易有限。
    3、 堆上分配，也称动态分配，如我们用new，malloc分配内存，用delete，free来释放的内存。
    十、内存分配的注意事项
    用new或malloc分配内存时，必须要对此指针赋初值。
    用delete 或free释放内存后，必须要将指针指向NULL
    不能修改指向常量的指针数据
    十一、内容复制与比较
 
 //数组……
char a[]=”Hello Word!”;
char b[10];
strcpy(b,a);
if (strcmp(a,b)==0)
{}
//指针……
char a[]=”Hello Word!”;
char *p;
p=new char[strlen(a)+1];
strcpy(p,a);
if (strcmp(p,a)==0)
{}  
十二、sizeof的问题
    记住一点，C++无法知道指针所指对象的大小，指针的大小永远为4字节
 
 char a[]=”Hello World!”
char *p=a;
count<
count<
而且，在函数中，数组参数退化为指针，所以下面的内容永远输出为4
void fun(char a[1000])
{
count<
}  
    十三、关于指针
    1、 指针创建时必须被初始化
    2、 指针在free 或delete后必须置为NULL
    3、 指针的长度都为4字节
    ４、释放内存时，如果是数组指针，必须要释放掉所有的内存，如
 
 char *p=new char[100];
strcpy(p,”Hello World”);
delete []p; //注意前面的［］号
p=NULL;  
    ５、数组指针的内容不能超过数组指针的最大容易。
    如：
 
 char *p=new char[5];
strcpy(p,”Hello World”); //报错 目标容易不够大
delete []p; //注意前面的［］号
p=NULL;  
    十四、关于malloc/free 和new /delete
     malloc/free 是C/C+的内存分配符，new /delete是C++的内存分配符。
     注意：malloc/free是库函数，new/delete是运算符
     malloc/free不能执行构造函数与析构函数，而new/delete可以
     new/delete不能在C上运行，所以malloc/free不能被淘汰
     两者都必须要成对使用
     C++中可以使用_set_new_hander函数来定义内存分配异常的处理
    十五、Ｃ++的特性
    Ｃ++新增加有重载（overload），内联（inline），Const，Virtual四种机制
    重载和内联：即可用于全局函数，也可用于类的成员函数；
    Const和Virtual：只可用于类的成员函数；
    重载：在同一类中，函数名相同的函数。由不同的参数决定调用那个函数。函数可要不可要Virtual关键字。和全局函数同名的函数不叫重载。如果在类中调用同名的全局函数，必须用全局引用符号：：引用。
    覆盖是指派生类函数覆盖基类函数
    函数名相同；
    参数相同；
    基类函数必须有Virtual关键字；
    不同的范围（派生类和基类）。
    隐藏是指派生类屏蔽了基类的同名函数相同
    1、 函数名相同，但参数不同，此时不论基类有无Virtual关键字，基类函数将被隐藏。
    2、 函数名相同，参数也相同，但基类无Virtual关键字（有就是覆盖），基类函数将被隐藏。
    内联：inline关键字必须与定义体放在一起，而不是单单放在声明中。
    Const：const是constant的缩写，“恒定不变”的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
    1、 参数做输入用的指针型参数，加上const可防止被意外改动。
    2、 按值引用的用户类型做输入参数时，最好将按值传递的改为引用传递，并加上const关键字，目的是为了提高效率。数据类型为内部类型的就没必要做这件事情；如：
    将void Func（A a） 改为void Func（const A &a）。
    而void func（int a）就没必要改成void func（const int &a）；
    3、给返回值为指针类型的函数加上const，会使函数返回值不能被修改，赋给的变量也只能是const型变量。如：函数const char*GetString（void）； char *str=GetString（）将会出错。而const char *str=GetString（）将是正确的。
    4、 Const成员函数是指此函数体内只能调用Const成员变量，提高程序的键壮性。如声明函数 int GetCount（void） const；此函数体内就只能调用Const成员变量。
    Virtual：虚函数：派生类可以覆盖掉的函数，纯虚函数：只是个空函数，没有函数实现体；
    十六、extern“C”有什么作用？
    Extern “C”是由Ｃ＋＋提供的一个连接交换指定符号，用于告诉Ｃ＋＋这段代码是Ｃ函数。这是因为C++编译后库中函数名会变得很长，与C生成的不一致，造成Ｃ＋＋不能直接调用C函数，加上extren “c”后，C++就能直接调用C函数了。
    Extern “C”主要使用正规DLL函数的引用和导出 和 在C++包含C函数或C头文件时使用。使用时在前面加上extern “c” 关键字即可。
    十七、构造函数与析构函数
    派生类的构造函数应在初始化表里调用基类的构造函数；
    派生类和基类的析构函数应加Virtual关键字。
    不要小看构造函数和析构函数，其实编起来还是不容易。
 
 #include
class Base
{
public:
virtual ~Base() { cout<< "~Base" << endl ; }
};
class Derived : public Base
{
public:
virtual ~Derived() { cout<< "~Derived" << endl ; }
};
void main(void)
{
Base * pB = new Derived; // upcast
delete pB;
}  
    输出结果为：
    ~Derived
    ~Base
    如果析构函数不为虚，那么输出结果为
    ~Base
    十八、#IFNDEF/#DEFINE/#ENDIF有什么作用
    仿止该头文件被重复引用

BOOL，int，float，指针变量 与“零值”比较的if语句
分别给出BOOL，int，float，指针变量 与“零值”比较的 if 语句（假设变量名为var）
    解答：
    BOOL型变量：if（！var）
    int型变量： if（var==0）
    float型变量：
    const float EPSINON = 0.00001；
    if （（x >= - EPSINON） && （x <= EPSINON）
    指针变量：　　if（var==NULL）
    剖析：
    考查对0值判断的“内功”，BOOL型变量的0判断完全可以写成if（var==0），而int型变量也可以写成if（！var），指针变量的判断也可以写成if（！var），上述写法虽然程序都能正确运行，但是未能清晰地表达程序的意思。一般的，如果想让if判断一个变量的“真”、“假”，应直接使用if（var）、if（！var），表明其为“逻辑”判断；如果用if判断一个数值型变量（short、int、long等），应该用if（var==0），表明是与0进行“数值”上的比较；而判断指针则适宜用if（var==NULL），这是一种很好的编程习惯。
    浮点型变量并不精确，所以不可将float变量用“==”或“！=”与数字比较，应该设法转化成“>=”或“<=”形式。如果写成if （x == 0.0），则判为错，得0分。






以下摘自《林锐－高质量c++c编程指南》 
/* ? ---------------------------------------------------------------------------- ? */ 
if语句是C++/C语言中最简单、最常用的语句，然而很多程序员用隐含错误的方式写if语句。本节以“与零值比较”为例，展开讨论。 


4.3.1 ? 布尔变量与零值比较 
&#61548; 【规则4-3-1】不可将布尔变量直接与TRUE、FALSE或者1、0进行比较。 
根据布尔类型的语义，零值为“假”（记为FALSE），任何非零值都是“真”（记为TRUE）。TRUE的值究竟是什么并没有统一的标准。例如Visual ? C++ ? 将TRUE定义为1，而Visual ? Basic则将TRUE定义为-1。 
假设布尔变量名字为flag，它与零值比较的标准if语句如下： 
if ? (flag) // ? 表示flag为真 
if ? (!flag) // ? 表示flag为假 
其它的用法都属于不良风格，例如： 
if ? (flag ? == ? TRUE) 
if ? (flag ? == ? 1 ? ) 
if ? (flag ? == ? FALSE) ? ? 
if ? (flag ? == ? 0) 


4.3.2 ? 整型变量与零值比较 
&#61548; 【规则4-3-2】应当将整型变量用“==”或“！=”直接与0比较。 
假设整型变量的名字为value，它与零值比较的标准if语句如下： 
if ? (value ? == ? 0) ? ? 
if ? (value ? != ? 0) 
不可模仿布尔变量的风格而写成 
if ? (value) // ? 会让人误解 ? value是布尔变量 
if ? (!value) ? 


4.3.3 ? 浮点变量与零值比较 
&#61548; 【规则4-3-3】不可将浮点变量用“==”或“！=”与任何数字比较。 
千万要留意，无论是float还是double类型的变量，都有精度限制。所以一定要避免将浮点变量用“==”或“！=”与数字比较，应该设法转化成“> =”或“ <=”形式。 
假设浮点变量的名字为x，应当将 
if ? (x ? == ? 0.0) ? // ? 隐含错误的比较 
转化为 ? 
if ? ((x> =-EPSINON) ? && ? (x <=EPSINON)) 
其中EPSINON是允许的误差（即精度）。 


4.3.4 ? 指针变量与零值比较 
&#61548; 【规则4-3-4】应当将指针变量用“==”或“！=”与NULL比较。 
指针变量的零值是“空”（记为NULL）。尽管NULL的值与0相同，但是两者意义不同。假设指针变量的名字为p，它与零值比较的标准if语句如下： 
if ? (p ? == ? NULL) // ? p与NULL显式比较，强调p是指针变量 
if ? (p ? != ? NULL) 
不要写成 
if ? (p ? == ? 0) ? // ? 容易让人误解p是整型变量 
if ? (p ? != ? 0) ? ? ? ? 
或者 
if ? (p) // ? 容易让人误解p是布尔变量 
if ? (!p) 


4.3.5 ? 对if语句的补充说明 
有时候我们可能会看到 ? if ? (NULL ? == ? p) ? 这样古怪的格式。不是程序写错了，是程序员为了防止将 ? if ? (p ? == ? NULL) ? 误写成 ? if ? (p ? = ? NULL)，而有意把p和NULL颠倒。编译器认为 ? if ? (p ? = ? NULL) ? 是合法的，但是会指出 ? if ? (NULL ? = ? p)是错误的，因为NULL不能被赋值。 
程序中有时会遇到if/else/return的组合，应该将如下不良风格的程序 
if ? (condition) 
return ? x; 
return ? y; 
改写为 
if ? (condition) 
{ 
return ? x; 
} 
else 
{ 
return ? y; 
} 
或者改写成更加简练的 ? 
return ? (condition ? ? ? x ? : ? y);

面向对象是C++的重要特性。
    但是c++在c的基础上新增加的几点优化也是很耀眼的就const直接可以取代c中的#define以下几点很重要，学不好后果也也很严重
    const
    1. 限定符声明变量只能被读
    const int i=5；
    int j=0；
    ……
    i=j；  //非法，导致编译错误
    j=i；  //合法
    2. 必须初始化
    const int i=5；    //合法
    const int j；      //非法，导致编译错误
    3. 在另一连接文件中引用const常量
    extern const int i；    //合法
    extern const int j=10；  //非法，常量不可以被再次赋值
    4. 便于进行类型检查
    用const方法可以使编译器对处理内容有更多了解。
    #define I=10
    const long &i=10；  /*dapingguo提醒：由于编译器的优化，使得在const long i=10； 时i不被分配内存，而是已10直接代入以后的引用中，以致在以后的代码中没有错误，为达到说教效果，特别地用&i明确地给出了i的内存分配。不过一旦你关闭所有优化措施，即使const long i=10；也会引起后面的编译错误。*/
    char h=I；      //没有错
    char h=i；      //编译警告，可能由于数的截短带来错误赋值。
    5. 可以避免不必要的内存分配
    #define STRING "abcdefghijklmn\n"
    const char string[]="abcdefghijklm\n"；
    ……
    printf（STRING）；  //为STRING分配了第一次内存
    printf（string）；  //为string一次分配了内存，以后不再分配
    ……
    printf（STRING）；  //为STRING分配了第二次内存
    printf（string）；
    ……
    由于const定义常量从汇编的角度来看，只是给出了对应的内存地址，而不是象#define一样给出的是立即数，所以，const定义的常量在程序运行过程中只有一份拷贝，而#define定义的常量在内存中有若干个拷贝。
    6. 可以通过函数对常量进行初始化
    int value（）；
    const int i=value（）；
    dapingguo说：假定对ROM编写程序时，由于目标代码的不可改写，本语句将会无效，不过可以变通一下：
    const int &i=value（）；
    只要令i的地址处于ROM之外，即可实现：i通过函数初始化，而其值有不会被修改。
    7. 是不是const的常量值一定不可以被修改呢？
    观察以下一段代码：
    const int i=0；
    int *p=（int*）&i；
    p=100；
    通过强制类型转换，将地址赋给变量，再作修改即可以改变const常量值。
    8. 请分清数值常量和指针常量，以下声明颇为玩味：
    int ii=0；
    const int i=0；            //i是常量，i的值不会被修改
    const int *p1i=&i；        //指针p1i所指内容是常量，可以不初始化
    int  * const p2i=&ii；    //指针p2i是常量，所指内容可修改
    const int * const p3i=&i； //指针p3i是常量，所指内容也是常量
    p1i=&ii；                  //合法
    *p2i=100；                //合法
    关于C++中的const关键字的用法非常灵活，而使用const将大大改善程序的健壮性，参考了康建东兄的const使用详解一文，对其中进行了一些补充，写下了本文。
  1.      const常量，如const int max = 100；
    优点：const常量有数据类型，而宏常量没有数据类型。编译器可以对前者进行类型安全检查，而对后者只进行字符替换，没有类型安全检查，并且在字符替换时可能会产生意料不到的错误（边际效应）
    2.      const 修饰类的数据成员。如：
 
 class A
{
    const int size;
    …
}  
    const数据成员只在某个对象生存期内是常量，而对于整个类而言却是可变的。因为类可以创建多个对象，不同的对象其const数据成员的值可以不同。所以不能在类声明中初始化const数据成员，因为类的对象未被创建时，编译器不知道const 数据成员的值是什么。如
 
 class A
{
const int size = 100;    //错误
int array[size];        //错误，未知的size
}  
    const数据成员的初始化只能在类的构造函数的初始化表中进行。要想建立在整个类中都恒定的常量，应该用类中的枚举常量来实现。如
 
 class A
{…
enum {size1=100, size2 = 200 };
int array1[size1];
int array2[size2];
}  
    枚举常量不会占用对象的存储空间，他们在编译时被全部求值。但是枚举常量的隐含数据类型是整数，其最大值有限，且不能表示浮点数。
    3.      const修饰指针的情况，见下式：
 
 int b = 500;
const int* a = &          [1]
int const *a = &          [2]
int* const a = &          [3]
const int* const a = &    [4]  
    如果你能区分出上述四种情况，那么，恭喜你，你已经迈出了可喜的一步。不知道，也没关系，我们可以参考《Effective c++》Item21上的做法，如果const位于星号的左侧，则const就是用来修饰指针所指向的变量，即指针指向为常量；如果const位于星号的右侧，const就是修饰指针本身，即指针本身是常量。因此，[1]和[2]的情况相同，都是指针所指向的内容为常量（const放在变量声明符的位置无关），这种情况下不允许对内容进行更改操作，如不能*a = 3 ；[3]为指针本身是常量，而指针所指向的内容不是常量，这种情况下不能对指针本身进行更改操作，如a++是错误的；[4]为指针本身和指向的内容均为常量。
    4.    const的初始化
    先看一下const变量初始化的情况
    1） 非指针const常量初始化的情况：A b；
    const A a = b；
    2） 指针const常量初始化的情况：
    A* d = new A（）；
    const A* c = d；
    或者：const A* c = new A（）；
    3）引用const常量初始化的情况：
    A f；
    const A& e = f；      // 这样作e只能访问声明为const的函数，而不能访问一
    般的成员函数；
    [思考1]： 以下的这种赋值方法正确吗？
    const A* c=new A（）；
    A* e = c；
    [思考2]： 以下的这种赋值方法正确吗？
    A* const c = new A（）；
    A* b = c；
    5.    另外const 的一些强大的功能在于它在函数声明中的应用。在一个函数声明中，const 可以修饰函数的返回值，或某个参数；对于成员函数，还可以修饰是整个函数。有如下几种情况，以下会逐渐的说明用法：
 
 A& operator=(const A& a);
void fun0(const A* a );
void fun1( ) const; // fun1( ) 为类成员函数
const A fun2( );  
    1） 修饰参数的const，如 void fun0（const A* a ）； void fun1（const A& a）；调用函数的时候，用相应的变量初始化const常量，则在函数体中，按照const所修饰的部分进行常量化，如形参为const A* a，则不能对传递进来的指针的内容进行改变，保护了原指针所指向的内容；如形参为const A& a，则不能对传递进来的引用对象进行改变，保护了原对象的属性。
    [注意]：参数const通常用于参数为指针或引用的情况，且只能修饰输入参数；若输入参数采用“值传递”方式，由于函数将自动产生临时变量用于复制该参数，该参数本就不需要保护，所以不用const修饰。
    [总结]对于非内部数据类型的输入参数，因该将“值传递”的方式改为“const引用传递”，目的是为了提高效率。例如，将void Func（A a）改为void Func（const A &a）
    对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func（int x）不应该改为void Func（const int &x）
    2）  修饰返回值的const，如const A fun2（ ）； const A* fun3（ ）；这样声明了返回值后，const按照"修饰原则"进行修饰，起到相应的保护作用。
 
 const Rational operator*(const Rational& lhs, const Rational& rhs)
{
return Rational(lhs.numerator() * rhs.numerator(),
lhs.denominator() * rhs.denominator());
}
返回值用const修饰可以防止允许这样的操作发生:Rational a,b;
Radional c;
(a*b) = c;  
    一般用const修饰返回值为对象本身（非引用和指针）的情况多用于二目操作符重载函数并产生新对象的时候。
    [总结]
    1.    一般情况下，函数的返回值为某个对象时，如果将其声明为const时，多用于操作符的重载。通常，不建议用const修饰函数的返回值类型为某个对象或对某个对象引用的情况。原因如下：如果返回值为某个对象为const（const A test = A 实例）或某个对象的引用为const（const A& test = A实例） ，则返回值具有const属性，则返回实例只能访问类A中的公有（保护）数据成员和const成员函数，并且不允许对其进行赋值操作，这在一般情况下很少用到。
    2.      如果给采用“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。如：
    const char * GetString（void）；
    如下语句将出现编译错误：
    char *str=GetString（）；
    正确的用法是：
    const char *str=GetString（）；
    3.    函数返回值采用“引用传递”的场合不多，这种方式一般只出现在类的赙值函数中，目的是为了实现链式表达。如：
 
 class A
{…
A &operate = (const A &other);  //负值函数
}
A a,b,c;              //a,b,c为A的对象
…
a=b=c;            //正常
(a=b)=c;          //不正常，但是合法  
    若负值函数的返回值加const修饰，那么该返回值的内容不允许修改，上例中a=b=c依然正确。（a=b）=c就不正确了。
    [思考3]： 这样定义赋值操作符重载函数可以吗？
    const A& operator=（const A& a）；
    6.    类成员函数中const的使用
    一般放在函数体后，形如：void fun（） const；
    任何不会修改数据成员的函数都因该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其他非const成员函数，编译器将报错，这大大提高了程序的健壮性。如：
 
 class Stack
{
public:
      void Push(int elem);
      int Pop(void);
      int GetCount(void) const;  //const 成员函数
private:
      int m_num;
      int m_data[100];
};
int Stack::GetCount(void) const
{
  ++m_num;              //编译错误，企图修改数据成员m_num
  Pop();                    //编译错误，企图调用非const函数
  Return m_num;
}  
    7.      使用const的一些建议
    1 要大胆的使用const，这将给你带来无尽的益处，但前提是你必须搞清楚原委；
    2 要避免最一般的赋值操作错误，如将const变量赋值，具体可见思考题；
    3 在参数中使用const应该使用引用或指针，而不是一般的对象实例，原因同上；
    4 const在成员函数中的三种用法（参数、返回值、函数）要很好的使用；
    5 不要轻易的将函数的返回值类型定为const；
    6除了重载操作符外一般不要将返回值类型定为对某个对象的const引用；
    [思考题答案]
    1 这种方法不正确，因为声明指针的目的是为了对其指向的内容进行改变，而声明的指针e指向的是一个常量，所以不正确；
    2 这种方法正确，因为声明指针所指向的内容可变；
    3 这种做法不正确；
    在const A：：operator=（const A& a）中，参数列表中的const的用法正确，而当这样连续赋值的时侯，问题就出现了：
    A a，b，c：
    （a=b）=c；
    因为a.operator=（b）的返回值是对a的const引用，不能再将c赋值给const常量。

==========================================================================================================

★ 相同点：
    1. 都是地址的概念；
    指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。
    ★ 区别：
    1. 指针是一个实体，而引用仅是个别名；
    2. 引用使用时无需解引用（*），指针需要解引用；
    3. 引用只能在定义时被初始化一次，之后不可变；指针可变；
    引用“从一而终” ^_^
    4. 引用没有 const，指针有 const，const 的指针不可变；
    5. 引用不能为空，指针可以为空；
    6. “sizeof 引用”得到的是所指向的变量（对象）的大小，而“sizeof 指针”得到的是指针本身（所指向的变量或对象的地址）的大小；
    typeid（T） == typeid（T&） 恒为真，sizeof（T） == sizeof（T&） 恒为真，但是当引用作为成员时，其占用空间与指针相同（没找到标准的规定）。
    7. 指针和引用的自增（++）运算意义不一样；
    ★ 联系
    1. 引用在语言内部用指针实现（如何实现？）。
    2. 对一般应用而言，把引用理解为指针，不会犯严重语义错误。引用是操作受限了的指针（仅容许取内容操作）。
    引用是C++中的概念，初学者容易把引用和指针混淆一起。一下程序中，n 是m 的一个引用（reference），m 是被引用物（referent）。
    int m；
    int &n = m；
    n 相当于m 的别名（绰号），对n 的任何操作就是对m 的操作。例如有人名叫王小毛，他的绰号是“三毛”。说“三毛”怎么怎么的，其实就是对王小毛说三道四。所以n 既不是m 的拷贝，也不是指向m 的指针，其实n 就是m 它自己。
    引用的一些规则如下：
    （1）引用被创建的同时必须被初始化（指针则可以在任何时候被初始化）。
    （2）不能有NULL 引用，引用必须与合法的存储单元关联（指针则可以是NULL）。
    （3）一旦引用被初始化，就不能改变引用的关系（指针则可以随时改变所指的对象）。
    以下示例程序中，k 被初始化为i 的引用。语句k = j 并不能将k 修改成为j 的引用，只是把k 的值改变成为6.由于k 是i 的引用，所以i 的值也变成了6.
    int i = 5；
    int j = 6；
    int &k = i；
    k = j； // k 和i 的值都变成了6；
    上面的程序看起来象在玩文字游戏，没有体现出引用的价值。引用的主要功能是传递函数的参数和返回值。C++语言中，函数的参数和返回值的传递方式有三种：值传递、指针传递和引用传递。
    以下是“值传递”的示例程序。由于Func1 函数体内的x 是外部变量n 的一份拷贝，改变x 的值不会影响n， 所以n 的值仍然是0.
 
 void Func1(int x)
{
x = x + 10;
}
int n = 0;
Func1(n);
cout << “n = ” << n << endl;// n = 0  
    以下是“指针传递”的示例程序。由于Func2 函数体内的x 是指向外部变量n 的指针，改变该指针的内容将导致n 的值改变，所以n 的值成为10.
 
 void Func2(int *x)
{
(* x) = (* x) + 10;
}
&#8943;
int n = 0;
Func2(&n);
cout << “n = ” << n << endl; // n = 10  
    以下是“引用传递”的示例程序。由于Func3 函数体内的x 是外部变量n 的引用，x和n 是同一个东西，改变x 等于改变n，所以n 的值成为10.
 
 void Func3(int &x)
{
x = x + 10;
}
&#8943;
int n = 0;
Func3(n);
cout << “n = ” << n << endl; // n = 10  
对比上述三个示例程序，会发现“引用传递”的性质象“指针传递”，而书写方式象“值传递”。实际上“引用”可以做的任何事情“指针”也都能够做，为什么还要“引用”
    这东西？
    答案是“用适当的工具做恰如其分的工作”。
    指针能够毫无约束地操作内存中的如何东西，尽管指针功能强大，但是非常危险。
    就象一把刀，它可以用来砍树、裁纸、修指甲、理发等等，谁敢这样用？
    如果的确只需要借用一下某个对象的“别名”，那么就用“引用”，而不要用“指针”，以免发生意外。比如说，某人需要一份证明，本来在文件上盖上公章的印子就行了，如果把取公章的钥匙交给他，那么他就获得了不该有的权利。
    ——————————
    摘自「高质量c＋＋编程」
    指针与引用，在More Effective C++ 的条款一有详细讲述，我给你转过来
    条款一：指针与引用的区别
    指针与引用看上去完全不同（指针用操作符‘*’和‘->’，引用使用操作符‘。’），但是它们似乎有相同的功能。指针与引用都是让你间接引用其他对象。你如何决定在什么时候使用指针，在什么时候使用引用呢？
    首先，要认识到在任何情况下都不能用指向空值的引用。一个引用必须总是指向某些对象。因此如果你使用一个变量并让它指向一个对象，但是该变量在某些时候也可能不指向任何对象，这时你应该把变量声明为指针，因为这样你可以赋空值给该变量。相反，如果变量肯定指向一个对象，例如你的设计不允许变量为空，这时你就可以把变量声明为引用。
    “但是，请等一下”，你怀疑地问，“这样的代码会产生什么样的后果？”
    char *pc = 0； // 设置指针为空值
    char& rc = *pc； // 让引用指向空值
    这是非常有害的，毫无疑问。结果将是不确定的（编译器能产生一些输出，导致任何事情都有可能发生），应该躲开写出这样代码的人除非他们同意改正错误。如果你担心这样的代码会出现在你的软件里，那么你最好完全避免使用引用，要不然就去让更优秀的程序员去做。我们以后将忽略一个引用指向空值的可能性。
    因为引用肯定会指向一个对象，在C里，引用应被初始化。
    string& rs； // 错误，引用必须被初始化
    string s（"xyzzy"）；
    string& rs = s； // 正确，rs指向s
    指针没有这样的限制。
    string *ps； // 未初始化的指针
    // 合法但危险
    不存在指向空值的引用这个事实意味着使用引用的代码效率比使用指针的要高。因为在使用引用之前不需要测试它的合法性。
 
 void printDouble(const double& rd)
{
     cout << rd; // 不需要测试rd,它
} // 肯定指向一个double值
相反，指针则应该总是被测试，防止其为空：
void printDouble(const double *pd)
{
     if (pd)
     { // 检查是否为NULL
           cout << *pd;
     }
}  
    指针与引用的另一个重要的不同是指针可以被重新赋值以指向另一个不同的对象。但是引用则总是指向在初始化时被指定的对象，以后不能改变。
 
 string s1("Nancy");
string s2("Clancy");
string& rs = s1; // rs 引用 s1
string *ps = &s1; // ps 指向 s1
rs = s2; // rs 仍旧引用s1,
// 但是 s1的值现在是
// "Clancy"
ps = &s2; // ps 现在指向 s2;
// s1 没有改变  
    总的来说，在以下情况下你应该使用指针，一是你考虑到存在不指向任何对象的可能（在这种情况下，你能够设置指针为空），二是你需要能够在不同的时刻指向不同的对象（在这种情况下，你能改变指针的指向）。如果总是指向一个对象并且一旦指向一个对象后就不会改变指向，那么你应该使用引用。
    还有一种情况，就是当你重载某个操作符时，你应该使用引用。最普通的例子是操作符[].这个操作符典型的用法是返回一个目标对象，其能被赋值。
 
 vector<int> v(10); // 建立整形向量（vector），大小为10;
// 向量是一个在标准C库中的一个模板(见条款35)
v[5] = 10; // 这个被赋值的目标对象就是操作符[]返回的值
如果操作符[]返回一个指针，那么后一个语句就得这样写：
*v[5] = 10;  
    但是这样会使得v看上去象是一个向量指针。因此你会选择让操作符返回一个引用。（这有一个有趣的例外，参见条款30）
    当你知道你必须指向一个对象并且不想改变其指向时，或者在重载操作符并为防止不必要的语义误解时，你不应该使用指针。而在除此之外的其他情况下，则应使用指针假设你有
 
void func(int* p, int&r);
int a = 1;
int b = 1;
func(&a,b);  
    指针本身的值（地址值）是以pass by value进行的，你能改变地址值，但这并不会改变指针所指向的变量的值，
    p = someotherpointer； //a is still 1
    但能用指针来改变指针所指向的变量的值，
    *p = 123131； // a now is 123131
    但引用本身是以pass by reference进行的，改变其值即改变引用所对应的变量的值
    r = 1231； // b now is 1231
    尽可能使用引用，不得已时使用指针。
    当你不需要“重新指向”时，引用一般优先于指针被选用。这通常意味着引用用于类的公有接口时更有用。引用出现的典型场合是对象的表面，而指针用于对象内部。
    上述的例外情况是函数的参数或返回值需要一个“临界”的引用时。这时通常最好返回/获取一个指针，并使用 NULL 指针来完成这个特殊的使命。（引用应该总是对象的别名，而不是被解除引用的 NULL 指针）。
    注意：由于在调用者的代码处，无法提供清晰的的引用语义，所以传统的 C 程序员有时并不喜欢引用。然而，当有了一些 C++ 经验后，你会很快认识到这是信息隐藏的一种形式，它是有益的而不是有害的。就如同，程序员应该针对要解决的问题写代码，而不是机器本身。

===============================================================================================================

一、 在c中分为这几个存储区
    1.栈 - 由编译器自动分配释放
    2.堆 - 一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收
    3.全局区（静态区），全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。- 程序结束释放
    4.另外还有一个专门放常量的地方。- 程序结束释放
    5 程序代码区，存放2进制代码。
    在函数体中定义的变量通常是在栈上，用malloc， calloc， realloc等分配内存的函数分配得到的就是在堆上。在所有函数体外定义的是全局量，加了static修饰符后不管在哪里都存放在全局区（静态区），在所有函数体外定义的static变量表示在该文件中有效，不能extern到别的文件用，在函数体内定义的static表示只在该函数体内有效。另外，函数中的"adgfdf"这样的字符串存放在常量区。比如：
 
 int a = 0; //全局初始化区
char *p1; //全局未初始化区
void main()
{
    int b; //栈
    char s[] = "abc"; //栈
    char *p2; //栈
    char *p3 = "123456"; //123456{post.content}在常量区，p3在栈上
    static int c = 0; //全局（静态）初始化区
    p1 = (char *)malloc(10); //分配得来得10字节的区域在堆区
    p2 = (char *)malloc(20); //分配得来得20字节的区域在堆区
    strcpy(p1, "123456");
    //123456{post.content}放在常量区，编译器可能会将它与p3所指向的"123456"优化成一块
}  
    二、在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区
    1.栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数参数等。
    2.堆，就是那些由new分配的内存块，他们的释放编译器不去管，由我们的应用程序去控制，一般一个new就要对应一个delete.如果程序员没有释放掉，那么在程序结束后，操作系统会自动回收。
    3.自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，不过它是用free来结束自己的生命的。
    4.全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的C语言中，全局变量又分为初始化的和未初始化的，在C++里面没有这个区分了，他们共同占用同一块内存区。
    5.常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许修改（当然，你要通过非正当手段也可以修改）
    三、 谈谈堆与栈的关系与区别
    具体地说，现代计算机（串行执行机制），都直接在代码底层支持栈的数据结构。这体现在，有专门的寄存器指向栈所在的地址，有专门的机器指令完成数据入栈出栈的操作。这种机制的特点是效率高，支持的数据有限，一般是整数，指针，浮点数等系统直接支持的数据类型，并不直接支持其他的数据结构。因为栈的这种特点，对栈的使用在程序中是非常频繁的。对子程序的调用就是直接利用栈完成的。机器的call指令里隐含了把返回地址推入栈，然后跳转至子程序地址的操作，而子程序中的ret指令则隐含从堆栈中弹出返回地址并跳转之的操作。C/C++中的自动变量是直接利用栈的例子，这也就是为什么当函数返回时，该函数的自动变量自动失效的原因。
    和栈不同，堆的数据结构并不是由系统（无论是机器系统还是操作系统）支持的，而是由函数库提供的。基本的malloc/realloc/free 函数维护了一套内部的堆数据结构。当程序使用这些函数去获得新的内存空间时，这套函数首先试图从内部堆中寻找可用的内存空间，如果没有可以使用的内存空间，则试图利用系统调用来动态增加程序数据段的内存大小，新分配得到的空间首先被组织进内部堆中去，然后再以适当的形式返回给调用者。当程序释放分配的内存空间时，这片内存空间被返回内部堆结构中，可能会被适当的处理（比如和其他空闲空间合并成更大的空闲空间），以更适合下一次内存分配申请。这套复杂的分配机制实际上相当于一个内存分配的缓冲池（Cache），使用这套机制有如下若干原因：
    1. 系统调用可能不支持任意大小的内存分配。有些系统的系统调用只支持固定大小及其倍数的内存请求（按页分配）；这样的话对于大量的小内存分类来说会造成浪费。
    2. 系统调用申请内存可能是代价昂贵的。系统调用可能涉及用户态和核心态的转换。
    3. 没有管理的内存分配在大量复杂内存的分配释放操作下很容易造成内存碎片。
    堆和栈的对比
    从以上知识可知，栈是系统提供的功能，特点是快速高效，缺点是有限制，数据不灵活；而栈是函数库提供的功能，特点是灵活方便，数据适应面广泛，但是效率有一定降低。栈是系统数据结构，对于进程/线程是唯一的；堆是函数库内部数据结构，不一定唯一。不同堆分配的内存无法互相操作。栈空间分静态分配和动态分配两种。静态分配是编译器完成的，比如自动变量（auto）的分配。动态分配由alloca函数完成。栈的动态分配无需释放（是自动的），也就没有释放函数。为可移植的程序起见，栈的动态分配操作是不被鼓励的！堆空间的分配总是动态的，虽然程序结束时所有的数据空间都会被释放回系统，但是精确的申请内存/ 释放内存匹配是良好程序的基本要素。
    1.碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细的可以>参考数据结构，这里我们就不再一一讨论了。
    2.生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。
    3.分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由编译器进行释放，无需我们手工实现。
    4.分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。
    明确区分堆与栈：
    在bbs上，堆与栈的区分问题，似乎是一个永恒的话题，由此可见，初学者对此往往是混淆不清的，所以我决定拿他第一个开刀。
    首先，我们举一个例子：
 
 void f()
{
    int* p=new int[5];
}  
    这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思就是：在栈内存中存放了一个指向一块堆内存的指针p.在程序会先确定在堆中分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地址，放入栈中，他在VC6下的汇编代码如下：
    00401028    push         14h
    0040102A    call            operator new （00401060）
    0040102F    add           esp，4
    00401032    mov          dword ptr [ebp-8]，eax
    00401035    mov          eax，dword ptr [ebp-8]
    00401038    mov          dword ptr [ebp-4]，eax
    这里，我们为了简单并没有释放内存，那么该怎么去释放呢？是delete p么？澳，错了，应该是delete []p，这是为了告诉编译器：我删除的是一个数组，VC6就会根据相应的Cookie信息去进行释放内存的工作。
    好了，我们回到我们的主题：堆和栈究竟有什么区别？
    主要的区别由以下几点：
    1、管理方式不同；
    2、空间大小不同；
    3、能否产生碎片不同；
    4、生长方向不同；
    5、分配方式不同；
    6、分配效率不同；
    管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆来说，释放工作由程序员控制，容易产生memory leak.
    空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。当然，我们可以修改：
    打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中选中Output，然后在Reserve中设定堆栈的最大值和commit.注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。
    堆和栈相比，由于大量new/delete的使用，容易造成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用堆。
    另外对存取效率的比较：代码：
 
 char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";  
    aaaaaaaaaaa是在运行时刻赋值的；
    而bbbbbbbbbbb是在编译时就确定的；
    但是，在以后的存取中，在栈上的数组比指针所指向的字符串（例如堆）快。
    比如：
 
 void main()
{
    char a = 1;
    char c[] = "1234567890";
    char *p ="1234567890";
    a = c[1];
    a = p[1];
    return;
}  
    对应的汇编代码
    10： a = c[1]；
    00401067 8A 4D F1 mov cl，byte ptr [ebp-0Fh]
    0040106A 88 4D FC mov byte ptr [ebp-4]，cl
    11： a = p[1]；
    0040106D 8B 55 EC mov edx，dword ptr [ebp-14h]
    00401070 8A 42 01 mov al，byte ptr [edx+1]
    00401073 88 45 FC mov byte ptr [ebp-4]，al
    第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。
    无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的结果，就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说不定什么时候就崩掉，编写稳定安全的代码才是最重要的。
    static用来控制变量的存储方式和可见性
    函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题： 如果想将函数中此变量的值保存至下一次调用时，如何实现？ 最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此 函数控制）。
    需要一个数据对象为整个类而非某个对象服务，同时又力求不破坏类的封装性，即要求此成员隐藏在类的内部，对外不可见。
    static的内部机制：
    静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。
    这样，它的空间分配有三个可能的地方，一是作为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的main（）函数前的全局数据声明和定义处。
    静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，所以在类声 明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。
    static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。
    static的优势：
    可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的 值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。
    引用静态数据成员时，采用如下格式：
    <类名>：：<静态成员名>
    如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员。
    PS：
    （1）类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致了它仅能访问类的静态数据和静态成员函数。
    （2）不能将静态成员函数定义为虚函数。
    （3）由于静态成员声明于类中，操作于其外，所以对其取地址操作，就多少有些特殊，变量地址是指向其数据类型的指针 ，函数地址类型是一个“nonmember函数指针”。
    （4）由于静态成员函数没有this指针，所以就差不多等同于nonmember函数，结果就产生了一个意想不到的好处：成为一个callback函数，使得我们得以将C++和C-based X W indow系统结合，同时也成功的应用于线程函数身上。
    （5）static并没有增加程序的时空开销，相反她还缩短了子类对父类静态成员的访问时间，节省了子类的内存空间。
    （6）静态数据成员在<定义或说明>时前面加关键字static.
    （7）静态数据成员是静态存储的，所以必须对它进行初始化。
    （8）静态成员初始化与一般数据成员初始化不同：
    初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆；初始化时不加该成员的访问权限控制符private，public等；
    初始化时使用作用域运算符来标明它所属类；
    所以我们得出静态数据成员初始化的格式：
    <数据类型><类名>：：<静态数据成员名>=<值>
    （9）为了防止父类的影响，可以在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点需要注意：我们说静态成员为父类和子类共享，但我们有 重复定义了静态成员，这会不会引起错误呢？不会，我们的编译器采用了一种绝妙的手法：name-mangling 用以生成唯一的标志。
    补充：new  delete［］，基本类型的对象没有析构函数（例如 int ， char ），所以回收基本类型组成的数组空间 delete  delete[] 都是应该可以如： int p = new int[10]， delete p 和delete[]p 都可 .但是对于类对象数组（如string strArr = new string[10]），只能 delete[].对 new 的单个对象，只能 delete 不能 delete[] 回收空间

==========================================================================================================

random和 rando多可以产生随机数，包含在stdlib.h里。
    random函数不是ANSI C标准，不能在gcc，vc等编译器下编译通过。但在C语言中int random（num）可以这样使用，它返回的是0至num-1的一个随机数。 可改用C++下的rand函数来实现。
    1、C++标准函数库提供一随机数生成器rand，返回0－RAND_MAX之间均匀分布的伪随机整数。 RAND_MAX必须至少为32767.rand（）函数不接受参数，默认以1为种子（即起始值）。 随机数生成器总是以相同的种子开始，所以形成的伪随机数列也相同，失去了随机意义。（但这样便于程序调试）
    2、C++中另一函数srand（），可以指定不同的数（无符号整数变元）为种子。但是如果种子相同，伪随机数列也相同。一个办法是让用户输入种子，但是仍然不理想。
    3、 比较理想的是用变化的数，比如时间来作为随机数生成器的种子。 time的值每时每刻都不同。所以种子不同，所以，产生的随机数也不同。
    rand运用问题与解答：
    问：为什么有时rand（）用它都是同一个数？如何产生一个真正随机数？
    答：之所以rand（）每次的随机数都一样是因为rand（）函数使用不正确。各种编程语言返回的随机数（确切地说是伪随机数）实际上都是根据递推公式计算的一组数值，当序列足够长，这组数值近似满足均匀分布。如果计算伪随机序列的初始数值（称为种子）相同，则计算出来的伪随机序列就是完全相同的。这个特性被有的软件利用于加密和解密。加密时，可以用某个种子数生成一个伪随机序列并对数据进行处理；解密时，再利用种子数生成一个伪随机序列并对加密数据进行还原。这样，对于不知道种子数的人要想解密就需要多费些事了。当然，这种完全相同的序列对于你来说是非常糟糕的。要解决这个问题，需要在每次产生随机序列前，先指定不同的种子，这样计算出来的随机序列就不会完全相同了。你可以在调用rand（）函数之前调用srand（ （unsigned）time（ NULL ） ），这样以time函数值（即当前时间）作为种子数，因为两次调用rand函数的时间通常是不同的，这样就可以保证随机性了。你也可以使用srand函数来人为指定种子数。Windows 9x/NT的游戏FreeCell就允许用户指定种子数，这样用户如果一次游戏没有成功，下次还可以以同样的发牌结果再玩一次。
    例子：
 
 #include <stdlib.h>
    #include <iostream.h>
    #include <conio.h>
    #include <time.h>
    void main()
    {
     srand( (unsigned)time( NULL ) ); //注意不要放在for循环里，否则产生的数是同一个数。
     for(int i=0;i<100000;i++)
     {
     cout<<rand()<<endl;
     }
    }  

============================================================================================================

sizeof（）功能：计算数据空间的字节数
    1.与strlen（）比较
    strlen（）计算字符数组的字符数，以"\0"为结束判断，不计算为'\0'的数组元素。
    而sizeof计算数据（包括数组、变量、类型、结构体等）所占内存空间，用字节数表示。
    2.指针与静态数组的sizeof操作
    指针均可看为变量类型的一种。所有指针变量的sizeof 操作结果均为4.
    注意：int *p； sizeof（p）=4；
    但sizeof（*p）相当于sizeof（int）；
    对于静态数组，sizeof可直接计算数组大小；
    例：int a[10]；char b[]="hello"；
    sizeof（a）等于4*10=40；
    sizeof（b）等于6；
    注意：数组做型参时，数组名称当作指针使用！！
    void  fun（char p[]）
    {sizeof（p）等于4}
    经典问题：
    double* （*a）[3][6]；
    cout<<sizeof（a）<<endl； // 4 a为指针
    cout<<sizeof（*a）<<endl； // 72 *a为一个有3*6个指针元素的数组
    cout<<sizeof（**a）<<endl； // 24 **a为数组一维的6个指针
    cout<<sizeof（***a）<<endl； // 4 ***a为一维的第一个指针
    cout<<sizeof（****a）<<endl； // 8 ****a为一个double变量
    问题解析：a是一个很奇怪的定义，他表示一个指向double*[3][6]类型数组的指针。既然是指针，所以sizeof（a）就是4.
    既然a是执行double*[3][6]类型的指针，*a就表示一个double*[3][6]的多维数组类型，因此sizeof（*a）=3*6*sizeof（double*）=72.同样的，**a表示一个double*[6]类型的数组，所以sizeof（**a）=6*sizeof  （double*）=24.***a就表示其中的一个元素，也就是double*了，所以sizeof（***a）=4.至于****a，就是一个double了，所以sizeof（****a）=sizeof（double）=8.
    3.格式的写法
    sizeof操作符，对变量或对象可以不加括号，但若是类型，须加括号。
    4.使用sizeof时string的注意事项
    string s="hello"；
    sizeof（s）等于string类的大小，sizeof（s.c_str（））得到的是与字符串长度。
    5.union 与struct的空间计算
    总体上遵循两个原则：
    （1）整体空间是 占用空间最大的成员（的类型）所占字节数的整倍数
    （2）数据对齐原则——内存按结构成员的先后顺序排列，当排到该成员变量时，其前面已摆放的空间大小必须是该成员类型大小的整倍数，如果不够则补齐，以此向后类推……
    注意：数组按照单个变量一个一个的摆放，而不是看成整体。如果成员中有自定义的类、结构体，也要注意数组问题。
    例：[引用其他帖子的内容]
    因为对齐问题使结构体的sizeof变得比较复杂，看下面的例子：（默认对齐方式下）
 
 struct s1
{
char a;
double b;
int c;
char d;
};
struct s2
{
char a;
char b;
int c;
double d;
};
cout<<sizeof(s1)<<endl; // 24
cout<<sizeof(s2)<<endl; // 16  
    同样是两个char类型，一个int类型，一个double类型，但是因为对齐问题，导致他们的大小不同。计算结构体大小可以采用元素摆放法，我举例子说明一下：首先，CPU判断结构体的对界，根据上一节的结论，s1和s2的对界都取最大的元素类型，也就是double类型的对界8.然后开始摆放每个元素。
    对于s1，首先把a放到8的对界，假定是0，此时下一个空闲的地址是1，但是下一个元素d是double类型，要放到8的对界上，离1最接近的地址是8了，所以d被放在了8，此时下一个空闲地址变成了16，下一个元素c的对界是4，16可以满足，所以c放在了16，此时下一个空闲地址变成了20，下一个元素d需要对界1，也正好落在对界上，所以d放在了20，结构体在地址21处结束。由于s1的大小需要是8的倍数，所以21-23的空间被保留，s1的大小变成了24.
    对于s2，首先把a放到8的对界，假定是0，此时下一个空闲地址是1，下一个元素的对界也是1，所以b摆放在1，下一个空闲地址变成了2；下一个元素c的对界是4，所以取离2最近的地址4摆放c，下一个空闲地址变成了8，下一个元素d的对界是8，所以d摆放在8，所有元素摆放完毕，结构体在15处结束，占用总空间为16，正好是8的倍数。
    这里有个陷阱，对于结构体中的结构体成员，不要认为它的对齐方式就是他的大小，看下面的例子：
 
 struct s1
{
char a[8];
};
struct s2
{
double d;
};
struct s3
{
s1 s;
char a;
};
struct s4
{
s2 s;
char a;
};
cout<<sizeof(s1)<<endl; // 8
cout<<sizeof(s2)<<endl; // 8
cout<<sizeof(s3)<<endl; // 9
cout<<sizeof(s4)<<endl; // 16;  
    s1和s2大小虽然都是8，但是s1的对齐方式是1，s2是8（double），所以在s3和s4中才有这样的差异。
    所以，在自己定义结构体的时候，如果空间紧张的话，最好考虑对齐因素来排列结构体里的元素。
    补充：不要让double干扰你的位域
    在结构体和类中，可以使用位域来规定某个成员所能占用的空间，所以使用位域能在一定程度上节省结构体占用的空间。不过考虑下面的代码：
 
 struct s1
{
　int i: 8;
　int j: 4;
　double b;
　int a:3;
};
struct s2
{
　int i;
　int j;
　double b;
　int a;
};
struct s3
{
　int i;
　int j;
　int a;
　double b;
};
struct s4
{
　int i: 8;
　int j: 4;
　int a:3;
　double b;
};
cout<<sizeof(s1)<<endl; // 24
cout<<sizeof(s2)<<endl; // 24
cout<<sizeof(s3)<<endl; // 24
cout<<sizeof(s4)<<endl; // 16  
    可以看到，有double存在会干涉到位域（sizeof的算法参考上一节），所以使用位域的的时候，最好把float类型和double类型放在程序的开始或者最后。
    相关常数：
    sizeof int：4
    sizeof short：2
    sizeof long：4
    sizeof float：4
    sizeof double：8
    sizeof char：1
    sizeof p：4
    sizeof WORD：2
    sizeof DWORD：4

=================================================================================================================

以下是林锐的原文：
for (i=0; i<N; i++)
{
if (condition)
? DoSomething();
else
? DoOtherthing();
} 
优点：程序简洁
缺点：多执行了N-1次逻辑判断，并且打断了循环“流水线”作业，使得编译器不能对循环进行优化处理，降低了效率。 
if (condition)
{
for (i=0; i<N; i++)
? DoSomething();
}
else
{
? for (i=0; i<N; i++)
? DoOtherthing();
}


优点：循环的效率高
缺点：程序不简洁

============================================================================================================

谈点我个人的看法哈，一家之言，欢迎拍砖。
    我个人理解，这二者其实没有太大差异性。
    C语言面向过程，OP，C++语言面向对象，OO.
    但实际上大家可能能关注到，不管如何OO，如何划分类和对象，但是，具体到一个功能，还是要用函数来实现，不管如何写程序，到了函数内部，其实还是那些if、for、while等等语句，还是面向过程的。
    所以，我和我的同事，平时并不会明显去分辨C和C++的异同，在我们看来，二者本来就是一体的。
    其实这个世界上，完全的OO是不存在的，当我们实现一个功能的时候，很多时候，就是界定一些数据，针对数据添加一些处理流程，获得一个结果，这件事情，本质上就是个过程。
    但C++还是很有用的。
    因为很多年以前，大家觉得传统面向过程的语言，如C，如Basic，如Pascal，都有一个缺点，就是在程序中，彼此暴露了太多的细节，这造成各个功能之间，由于程序员的失误，很容易发生粘连，联系。换而言之，就算是非法访问，通常也是合法而成功的，不会被编译器检查出来。比如C就允许全局变量和远指针调用。
    这在开发大型系统的时候，就出现了bug率居高不下，大型工程项目很难完成的缺点。
    正是因为此，大家在上世纪七十年代，提出了模块化开发的思想，试图通过各个模块的独立开发和运行，强行阻断各个模块不必要的耦合性，来达到让程序稳定的目的。
    但这样毕竟是人工在操作，是人做的，就可能会犯错误，大家觉得有必要在编译器这一级，要强调模块之间的独立性。
    这个时候，大家经过分析，发现程序其实核心是和数据打交道的，一个数据，业务上只要界定了用途，基本上，可能的访问方法就确定得差不多了，那么，我们有没有可能，把一类数据，以及其方法，从编译器的角度区别开来，构建独立模块，外部模块仅能访问到它允许访问的方法，其他的方法，全部报错，拒绝编译呢？
    答案是当然可以。大家就这么做了。那么，我们看看，一类数据和其允许的方法的集合，就是对象啦，在这个思想上，OO，面向对象的思想就产生了。
    最初，这个语言是一个新的语言，好像叫smalltalk吧，不过，这个时候的语言，还是实验室产品，没有投入商业运营。
    但这个时候，市场上，由于UNIX的推动，C语言基本上已经一统天下了。很多人都学的C语言，让大家去学习一门新语言，尤其是开发思路完全不同的语言，是不可想象的，成本太高。大家就想，能不能折中一下，以C的语法为蓝本，开发一套OO的语言，C++就这么诞生了。
    其实OP到OO，C到C++，本质上讲，就是一个数据私有化的过程。甚至整个语言的发展史，也是一个数据私有化的过程。如汇编语言，其实是没有私有数据的，所有的内存都可以被访问。
    人们通过编译器的界定和完善，逐渐实现数据私有化，最终的目标就是实现一个软件系统内部各个模块之间，高内聚，低耦合的目标，最终保证程序员的产品质量，进而提高生产率。
    至于后面的泛型编程，多态，继承等等，无非是在这条路上继续了一步而已，当然，也是为了尽量减少程序员的代码输入量，进一步提升生产效率而已。
    所以，从数据组织上讲，C++比C先进了一大步，但从功能实现上讲，C++和C并无本质不同。C++到现在，都不是一种完全的面向对象语言，因为它都仍然保留了全局变量。
    所以我的意见，两个一起学，不要刻意去区分，好像用C就要用纯C，没必要。
    我们工程中，系统级的模块组织，一般式C++的对象，每个单步功能，流程的实现，我们都是C的函数，仅仅是放在类里面而已。

======================================================================================================

为什么 要虚析构函数
2009-10-29 20:19:47|  分类： c++ |  标签： |字号大中小 订阅 
.#include <iostream>
using namespace std;
class A
{
public:    
     A(){cout << "A" << endl;}
     virtual ~A(){cout << "~A" << endl;}
};
class B : public A
{
public:
    B(){cout << "B" << endl;}
    virtual ~B(){cout << "~B" << endl;}
};
int main()
{
    A *p = new B;
    delete p; 
    return 0;
}
-----------
说明虚析构函数的目的在于在使用delete运算符删除一个对象时，能保析构函数被正确地执行 
如上例子如果基类的析构函数没有声明为虚析构函数（也就是把virtual去掉） 
那么输出的结果是A 
              B 
              ~A 
而派生类B的虚构函数没有被调用，导致内存泄漏 
如果声明为虚析构函数则输出的结果是 
A 
B 
~B 
~A
---------------=====================
我的理解：有两种情况是要定义虚析构的 
1.如果基类中有虚函数，否则如所说，用基类指针去析构派生类，会析构不完全。 


2.如果派生类自定义了operator delete()函数，这时不管基类中是否有没有虚函数都要虚析构。否则会用你不希望的方式去析构。
==================================================================
如果子类覆盖的父类的虚函数
则父类的指针或引用实际指向子类的对象
那通过该指针或引用调用虚函数时，则将调用子类的（虚）函数，如果不是虚函数，则将调用父类的函数 
=================================================================


1) 虚函数是动态绑定的，也就是说，使用虚函数的指针和引用能够正确找到实际类的对应函数，而不是执行定义类的函数。这是虚函数的基本功能，就不再解释了。 


2) 构造函数不能是虚函数。而且，在构造函数中调用虚函数，实际执行的是父类的对应函数，因为自己还没有构造好, 多态是被disable的。 


3) 析构函数可以是虚函数，而且，在一个复杂类结构中，这往往是必须的。


4) 将一个函数定义为纯虚函数，实际上是将这个类定义为抽象类，不能实例化对象。 


5) 纯虚函数通常没有定义体，但也完全可以拥有。


6)  析构函数可以是纯虚的，但纯虚析构函数必须有定义体，因为析构函数的调用是在子类中隐含的。 


7) 非纯的虚函数必须有定义体，不然是一个错误。 


8) 派生类的override虚函数定义必须和父类完全一致。除了一个特例，如果父类中返回值是一个指针或引用，子类override时可以返回这个指针（或引用）的派生。例如，在上面的例子中，在Base中定义了 virtual Base* clone(); 在Derived中可以定义为 virtual Derived* clone()。可以看到，这种放松对于Clone模式是非常有用的。 
其他，有待补充。
zz   http://www.cnblogs.com/chio/archive/2008/09/04/888260.html 
============================================================================
那么在、当pBase指针被撤消时，调用的是CBase的析构函数还是CChild的呢？ 
显然是CBase的(静态联编)。但如果把CBase类的析构函数改成virtual型，当pBase指针被撤消时，就会先调用CChild类析构函数，再调用CBase类析构函数（特别是当派生类中已经存在内存的申请，析构函数中存在内存的释放）
================================================================
构造函数为什么不能虚化：
1 构造一个对象的时候，必须知道对象的实际类型，而虚函数行为是在运行期间确定实际类型的。而在构造一个对象时，由于对象还未构造成功。编译器无法知道对象的实际类型，是该类本身，还是该类的一个派生类，或是更深层次的派生类。无法确定。。。
2 虚函数的执行依赖于虚函数表。而虚函数表在构造函数中进行初始化工作，即初始化vptr，让他指向正确的虚函数表。而在构造对象期间，虚函数表还没有被初始化，将无法进行。
===============================================================
模板成员函数不能为虚函数：
当前的编译器都期望在处理类的定义的时候就能确定这个类的虚函数表的大小，如果允许有类的虚成员模板函数，那么就必须要求编译器提前知道程序中所有对该类的该虚成员模板函数的调用，而这是不可行的。
==============================================================














基类的析构函数为什么要设成虚函数 
#include <iostream.h>
class A 
{
public:
 A(){cout<<"A()\n";}
 ~A(){cout<<"~A()\n";}
 
};
class B : public A 
{
public:
 B(){cout<<"B()\n";}
 ~B(){cout<<"~B()\n";}
};
void main() 
{
 A * p = new B();
 delete p ;  
}
输出结果：
A()
B()
~A()
============================================================
在基类的析构函数前添加virtual改编后的代码：
#include <iostream.h>
class A 
{
public:
 A(){cout<<"A()\n";}
 virtual ~A(){cout<<"~A()\n";}
 
};
class B : public A 
{
public:
 B(){cout<<"B()\n";}
 ~B(){cout<<"~B()\n";}
};
void main() 
{
 A * p = new B();
 delete p ;  
}
输出结果：
A()
B()
~B()
~A()
=================================================================
如果不是在基类的析构函数前添加virtual，而是在子类的析构函数前添加virtual，则编译不会出错，但是运行会出错。如果在此基础上再把“delete p;”这句话给注释了，那依然不会运行出错，不过这就不符合变成规范了，只要是我们自己用new创建的东西，我们就必须在适当的位置显示的调用delete来删除。
=================================================================
如果再添加一个中间类，代码如下：
#include <iostream.h>
#include <windows.h>
class A 
{
public:
 A(){cout<<"A()\n";}
 virtual ~A(){cout<<"~A()\n";}
};
class B : public A 
{
public:
 B(){cout<<"B()\n";}
 virtual ~B(){cout<<"~B()\n";}
};
class C : public B
{
public:
 C(){cout<<"C()\n";}
 ~C(){cout<<"~C()\n";}
};
void main() 
{
 A * p = new C();
 delete p ;  
}
输出结果为：
A()
B()
C()
~C()
~B()
~A()
析构函数前添加virtual，必须要在最最根上的基类的析构函数前添加，不能再B类或C类的析构函数前添加，只要A类的析构函数添加了virtual，从A类派生的类都不必在自己的析构函数前添加virtual了。
所以如果没有虚析构函数的话, 那么子类中特有的部分就不会被释放, 造成"经典"的释放一半, 泄露一半的内存泄露.