c,c++内存运行时深入研究

• C/C++内存与运行时深入研究 [作者Jean.Love] 
• -----------------------------------------------------------------------------------
• (一)整数符号的陷阱 
• (二)浮点数的本质 
• (三)堆栈的内存管理结构 
• (四)符号解析 
• (五)对齐和总线错误 
• (六)函数指针 
• (七)虚函数的实现机理 
• (八)引用的实现机理 
• (九)虚拟继承对象的内存结构 
• (十)混合编程时的初始化顺序 
• (十一)数组和指针的异同 
• (十二)const限定的传递性 
• (十三)数据类型的限定性检查 
• (十四)使用STL时的类型限制 
• (十五)迭代器自身的类型 
• (十六)运行时的类型信息 
• (十七)new/delete重载 
• (十八)如何拷贝一个文件 
• (一)整数符号的陷阱 
•         x
• #include
• int main(void){ 
• int x=1; 
• unsigned int y=2; 
• int b=x
• int b2=(x-y<0); 
• printf("%d,%d/n",b,b2); 
• return 0; 
• } 
• 它输出什么呢？ 
• 1,0 
•     令人震惊，不是吗，x
• (1)x
• (2)x-y的结果计算的时候，返回一个0xfffffffe，它被当成无符号数字理解并和0比较，显然<0不成立，返回0。 
• 总结一下，整数的运算，加减乘的时候，根本不管是否声明为是否有符号，在2进制cpu上面的计算是相同的，但是比较的时候(<,>,==)会根据类型，调用不同的比较指令，也就是以不同的方式来理解这个2进制结果。当signed和unsigned混用的时候，全部自动提升为无符号整数。 
• #include
• int main(void){ 
• int i=-2; 
•   unsigned j=1; 
• if(j+i>1) //提升为两个uint相加
•     printf("sum=%d/n",j+i);//打印的结果根据%d制定，j+i的内存值永远不变。
• return 0; 
• } 
• 输出 
• > ./a.out
• sum=-1 
• 再举一个例子 
• #include
• int main(void){ 
• int i=-4; 
• unsigned int j=1; 
• int ii=i+j; 
• unsigned int jj=i+j; 
• printf("%d,%ud/n",ii,jj); 
• if(ii>1){printf("100000");} 
• if(jj>1){printf("100001");} 
• return 0; 
• } 
• 用gcc -S得到汇编，会发现if(ii>1)和if(jj>1)对应两个不同的跳转指令jle和jbe。 
• 总结: int和unit在做比较操作和除法的时候不同，其他情况相同。 
• 返回页首 
• (二)浮点数的本质 
•         用一个程序来说明浮点数的IEEE表示。注意Linux没有atoi,ltoi,itoa这样的函数，那几个函数是VC独家提供的，不是ANSI C标准，所以*nix要用到sprintf函数来打印整数的内容到字符串里面。IEEE浮点数对于32位的float来说，从高位到低位分别是1bit符号位，8bit指数位，23bit浮点数位。当然由于内存地址是从低到高排列的，所以要把这4个字节的内容反过来，作为整数，转换为字符串打印出来的内容才是正确的。在x86机器上，同样是低位字节在前高位字节在>后，这样做得好处就是可以把浮点数作为有符号整数来排序。 
•         例如浮点书-0.875，符号为1(复数)，二进制表示为-0.111，表示为1-2之间的小鼠就是-1.11 x 2^-1，指数项-1，加上128得到1111111(127)，因为指数项的8个bit必须保证是无符号数，所以有了这样的表示。而23bit的整数项则是11000000000000000000，也就是取了-1.11在小数点后面的内容，没有的后端补0。 
• 所以，-0.875f的2进制表示就是10111111011000000000000000000000。写一个小程序来验证 
• #include
• #include
• void pfloat(float f){ 
• int i,j; 
• char buf[4][9]; 
• char* p=(char*)&f; 
•   printf("before loop/n"); 
• for(i=0;i<4;++i){ 
• for(j=0;j<8;++j){ 
•     buf[i][j]=(p[i]&(0x80>>j))>0?'1':'0'; 
•    } 
•    buf[i][8]='/0'; 
•   } 
• for(i=3;i>=0;i--){ 
•    printf("%s",buf[i]); 
•   } 
•   printf("/n"); 
•   printf("end loop/n"); 
• } 
• int main(void){ 
• float d1=-0.875; 
•   pfloat(d1); 
• return 0; 
• } 
•         看看输出和我们预期的一致。浮点数的计算总是充满了陷阱。首先，因为浮点数的精度有限，所以在做四则运算的时候，低位很可能在过程中被舍弃。因此，浮点运算不存在严格的运>算的结合律。在32位系统上面，浮点数float为4字节长，其中整数位23位，表示范围转换为10位数的话有9个有效数字。所以 
• float f1=3.14; 
• float f2=1e20; 
• float f3=-1e20; 
•   printf("%d,%f/n",i,f); 
•   printf("%f/n",f1+f2+f3); 
•   printf("%f/n",f2+f3+f1); 
•     上面两个printf的结果是不一样的，第一个结果是0，第二个结果是3.14。再举一个例子 
• float k=1.3456789; 
• float k2=k; 
•   k-=1000000.0; 
•   printf("%f/n",k); 
•   k+=1000000.0; 
•   printf("%f/n",k); 
• int b=(k==k2); 
•   printf("%d/n",b); 
•     结果是什么呢? b=0，因为k的值在之前的运算中，小数点后面已经有5为被舍入了，所以k不再等于k2。要使得k==k2成立，必须提高京都，使用double--52位整数域，相当于10进制有效数字16位，可以克服上面这个运算的不精确性。 
• double d1,d2; 
•   printf("%f/n",d1); 
•   d1=d2=1.3456789; 
•   d2+=1000000.0; 
•   printf("%f/n",d2); 
•   d2-=1000000.0; 
•   printf("%f/n",d2); 
•         现在d==d2的返回值就是真了。为了使得运算结果有可以比较的意义，通常定义一个门限值。#define fequals(a,b) fabs(a-b)<0.01f 
•         如果浮点数计算溢出，printf能够输出适当的表示 
• float nan=3.0f/0.0f; 
•   printf("%f/n",nan); 
• 打印inf，如果结果是负无穷大，打印-inf。 
• 返回页首 
• (三)堆栈的内存管理结构 
•         堆和栈的内存管理(x86机器)与分布是什么样子的？用一个程序来说明问题。看看堆和栈的空间是怎么增长的。 
• $ cat stk.c 
• #include
• #include
• int main(void){ 
• int x=0; 
• int y=0; 
• int z=0; 
• int *p=&y; 
• *(p+1)=2;//这条语句究竟是设置了x还是设置了z？和机器的cpu体系结构有关
• int* px=(int*)malloc(sizeof(int)); 
• int* py=(int*)malloc(sizeof(int)); 
• int* pz=(int*)malloc(sizeof(int)); 
• *px=1; 
• *py=1; 
• *pz=1; 
• *(py+1)=3; 
• printf("%d,%d,%d/n",x,y,z); 
• printf("%p,%p,%p/n",px,py,pz); 
• printf("%d,%d,%d/n",*px,*py,*pz); 
• free(px); 
• free(py); 
• free(pz); 
• return 0; 
• } 
• 编译和运行的结果 
• $ gcc stk.c && ./a.out
• 2,0,0 
• 0x9e8b008,0x9e8b018,0x9e8b028 
• 1,1,1 
• (1)如果把上面的分配内存的代码改成 
• int* px=(int*)malloc(sizeof(int)*3); 
• int* py=(int*)malloc(sizeof(int)*3); 
• int* pz=(int*)malloc(sizeof(int)*3); 
• 第三个printf的输出仍然是 
• 0x9e8b008,0x9e8b018,0x9e8b028 
•         说明什么呢? malloc分配的时候，分配的大小总是会比需要的大一些，也就是稍微有一些不大的内存越界并不会引起程序崩溃。当然这种情况可能导致得不到正确的结果。 
•         我们看看堆和栈的内存分布吧，在一台安装了Linux的x86机器上 
• --------------------- 
• 0xffffffff 
• ->OS内核代码，占据1/4的内存地址空间 
• 0xc000000 
• ->stack是运行时的用户栈，地址从高往低增长 
• |     x 
• |     y           ->int*(&y)+1指向的就是x 
• |     z 
• ->共享库的存储器映射区域 
• 0x40000000 
• ->运行时堆，往上增长 
• |    pz 
• 。。。。。。 
• |    py           ->由于py分配的内存大于实际想要的， *(py+1)=3;不对程序结果有影响 
• 。。。。。。 
• |    px           ->malloc分配的内存从低往高分配 
• 。。。。。。 
• ->可读写数据区(全局变量等) 
• ->只读代的代码和数据(可执行文件，字面常量等) 
• 0x08048000        ->是的，代码总是从同一地址空间开始的 
• ->未使用 
• 0x00000000 
• --------------------- 
• 如果把程序改为 *(py+4)=3; 
• 那么程序最好一行的输出就是 
• 1,1,3 
• 也就是pz的内容被写入。验证了理论。 
• 返回页首 
• (四)符号解析 
•         符号是怎么被解析的？什么时候会有符号解析的冲突？假设两个模块里面都有全局变量 
• $ cat f.c 
• #include
• int i=0; 
• void f(){ 
•   printf("%d/n",i); 
• } 
• $ cat m.c 
• int i=3; 
• extern void f(); 
• int main(void){ 
• f(); 
• return 0; 
• } 
• 这样的话，编译和链接会有错误： 
• $ gcc -o main m.o f.o 
• f.o:(.bss+0x0): multiple definition of `i' 
• m.o:(.data+0x0): first defined here 
• collect2: ld 返回 1 
• 也就是说，我们定义了重名的全局变量i，那么链接器就不知道应该用哪个i了，用nm可以看到符号表： 
• $ nm m.o f.o 
• m.o: 
•          U f 
• 00000000 D i 
• 00000000 T main 
• f.o: 
• 00000000 T f 
• 00000000 B i 
•          U printf 
• 解决方法有两种： 
• 1. 在m.c里面把int i=3变成main内部的局部变量，这样的话： 
• $ cat mcp.c 
• extern void f(); 
• int main(void){ 
• int i=3; 
• f(); 
• return 0; 
• } 
• [zhang@localhost kg]$ nm mcp.o 
•          U f 
• 00000000 T main 
• 在文件m.o中没有了全局符号i，链接就没有了错误。 
• 2.在f.c中把int i从全局变量变成static静态变量，使得它只在当前文件中可见 
• $ cat fcp.c 
• #include
• static int i=0; 
• void f(){ 
•   printf("%d/n",i); 
• } 
• [zhang@localhost kg]$ nm fcp.o 
• 00000000 T f 
• 00000000 b i     ->这里i的类型从以前的B变成了b 
•          U printf 
• main的执行结果是0，也就是f里面的i就是当前文件的i，不会使用m.c中定义的全局i。这两个i由于不冲突，就被定义在不同的地址上面了。 
• 返回页首 
• (五)对齐和总线错误 
•         什么是Bus error? 一般是总线寻址造成的，由于指针类型和long有相同大小，cpu总是找到%4/%8的地址作为指针的起始地址，例如： 
• #include
• int main(void){ 
• char buf[8]={'a','b','c','d','e','f'}; 
• char *pb=&(buf[1]);     //这里pb的地址不是4bytes或8bytes对齐的，而是从一个奇数地址开始
• int *pi=(int*)pb; 
• printf("%d/n",*pi); 
• return 0; 
• } 
•        这类问题的结果和CPU的体系结构有关，取决于CPU寻址的时候能否自动处理不对齐的情况。下面这个小程序是一个例子。分别在 Sparc(solaris+CC)和x86(vc6.0)上面测试: Sparc上面就会崩溃(Bus error (core dumped))，x86就没有问题。 
•        Plus: 在hp的pa-risc(aCC),itanium(aCC),IBM(xlC)的power上面测试 
• power不会core dump, pa-risc和Itanium也均core dump. 
• 返回页首 
• (六)函数指针 
•        要控制函数的行为，可以为函数传入一个回调函数作为参数。C++的STL使用的是functional算子对象，C语言可以传递一个函数或者一个函数指针。 
• #include
• #include
• typedef void callback(int i); 
• void p(int i){printf("function p/n");} 
• void f(int i,callback c){c(i);} 
• int main(void) 
• { 
• f(20,p); 
• return 0; 
• } 
• > ./a.out
• function p 
•     既然可以把函数直接作为回调参数传给另一个主函数，为什么还要用函数指针呢? 相像一下f函数运行在一个后台线程里面，这个线程是个服务器不能被停止，那么我们想要动态改变f的行为就不可能了，除非f的第二个参数是 callback* 而传入的这个变量我们去另一个线程里面改变。这样就实现了灵活性。 
• 返回页首 
• (七)虚函数的实现机理 
•     因为C++里面有指针，所以所谓的public，private在强类型转换面前没有意义。我们总是可以拿到私有的成员变量。 winXP+gcc3.4.2得到的虚函数表最后一项是0，是个结束符。注意，这是严重依赖编译器的，C++标准甚至都没要求是要用虚函数表来实现虚函数机制。 
• /*----------------------------------------------------------------------------*/
• #include
• class B{ 
• int x; 
• virtual void f(){printf("f/n");} 
• virtual void g(){printf("g/n");} 
• virtual void h(){printf("h/n");} 
• public: 
• explicit B(int i) {x=i;} 
• }; 
• typedef void (*pf)(); 
• int main(void){ 
•   B b(20); 
• int * pb=(int*)&b; 
•   printf("private x=%d/n",pb[1]); 
•   pf *pvt=(pf*)pb[0];//虚函数表指针
•   pf f1=(pf)pvt[0]; 
•   pf f2=(pf)pvt[1]; 
•   pf f3=(pf)pvt[2]; 
•   (*f1)(); 
•   (*f2)(); 
•   (*f3)(); 
•   printf("pvt[3]=%d/n",pvt[3]);//虚函数表结束符号
• return 0; 
• } 
• 程序输出 
• private x=20 
• f 
• g 
• h 
• pvt[3]=0 
•     理解的关键是，b的第一个dword，里面保存了一个指针，指向虚函数表。我们用两次强制转型，一次得到b的第一个dword，在把这个dword转为 
•     当然，上面的这个结果是和编译器类型以及版本有关系的，gcc2.95.2版本对象的结构就不同，它把虚函数表指针放到了对象的后面，也就是pvt= ((int*)(&b))[1]才是指针域，而且pvt[0]=0是结束符，pvt[1]才是第一个虚函数的起始地址。所以这样写出来的程序是不通用的。同一台机器上，不同的编译器来编上面那个程序，有的能工作，有的coredump。因为C++对象的内存模型不是C++标准的一部分，可以有不同的实现，不同实现编出来的结果(和虚函数有关的)互相之间没有任何通用性。 
•     如果有访问对象的成员呢? 情况更复杂。 
• #include
• using namespace std; 
• struct a{ 
• int x; 
• virtual void f(){printf("f(),%d/n",x);} 
• explicit a(int xx){x=xx;} 
• }; 
• int main(void){ 
•   a a1(2); 
•   a a2(3); 
• int* pi=(int*)&a1; 
• int* pvt=(int*)pi[0]; 
•   typedef void(*pf)(); 
•   pf p=(pf)pvt[0]; 
•   (*p)(); 
• int *p2=(int*)&a2; 
• int *pv2=(int*)p2[0]; 
•   pf px=(pf)pv2[0]; 
•   (*px)(); 
• return 0; 
• } 
• 输出是什么呢? 
• $ g++ r.cpp &&./a.out
• f(),3 
• f(),3 
•    为什么会有这样的错误? 因为成员函数在传递参数的时候默认含有一个this指针，但是我这里的简单调用并没有去指定this指针，所以程序没有挂掉就已经很幸运了。怎么才能得到正确的结果呢? 像下面这样增加一个this类型的调用参数: 
• #include
• struct a{ 
• int x; 
• virtual void f(){printf("f(),%d/n",x);}//............
• explicit a(int xx){x=xx;} 
• }; 
• int main(void){ 
•   a a1(2); 
•   a a2(3); 
• int* pi=(int*)&a1; 
• int* pvt=(int*)pi[0]; 
•   typedef void(*pf)(a*); 
•   pf p=(pf)pvt[0]; 
•   (*p)(&a1); 
• int *p2=(int*)&a2; 
• int *pv2=(int*)p2[0]; 
•   pf px=(pf)pv2[0]; 
•   (*px)(&a2); 
• return 0; 
• } 
• > g++ p.cpp && ./a.out
• f(),2 
• f(),3 
• 现在结果就正确了。 
•     再次说明，this指针的传递方法在C++标准里面并没有说明，而是各家编译器各自实现。这里引用OwnWaterloo的一段解释性代码，说明问题。 
• (1)gcc3.4.x 是通过给参数列表增添一个隐藏参数， 来传递this的， 代码 ： 
• /*----------------------------------------------------------------------------*/
• class C { 
• int i_; 
• public: 
• explicit C(int i) :i_(i) {} 
• virtual ~C() {} 
• virtual void f() { printf("C::f(%d)/n",i_); } 
• }; 
• #if defined(__GNUC__)
• #if __GNUC__!=3
• #error not test on other gcc version except gcc3.4
• #endif
• #include
• #include
• #include
• #define intprt_t int*
• int main() 
• { 
•     C c1(1212); 
•     C c2(326); 
•     typedef void (* virtual_function)(C*); 
• // gcc 通过一个增加一个额外参数， 传递this
• // virtual_function 即是C的虚函数签名
• struct
•     { 
•         virtual_function* vptr; 
• // 虚函数表指针
• // 当然，它指向的表不全是函数， 还有RTTI信息
• // 总之， 它就是这个类的标识， 唯一的“类型域”
• int i; 
• // data member
•     } caster; 
• // 我们猜想， gcc将虚函数表指针安排在对象的最前面。
•     memcpy(&caster,&c1,sizeof(caster)); 
•     printf("c1.i_ = %d/n",caster.i); // 1212
•     printf("c1.vptr_ = %p/n"
•         ,reinterpret_cast(reinterpret_cast(caster.vptr)) ); 
•     virtual_function* vptr1 = caster.vptr; 
•     memcpy(&caster,&c2,sizeof(caster)); 
•     printf("c2.i_ = %d/n",caster.i); 
•     printf("c2.vptr_ = %p/n",(void*)caster.vptr); 
•     virtual_function* vptr2 = caster.vptr; 
•     assert(vptr1==vptr2); 
• // 显然， 它们都是C， 所以vptr指向相同的地址
•     vptr1[2](&c1); // C::f(1212)
•     vptr2[2](&c2); // C::f(326)
• /* 我们再猜想 f在虚函数表中的第2项。这里的~C是虚函数表第1项。*/
• /* 在存在有虚析构函数的时候，虚表的第0项似乎只是个导引。如果把~C去掉改为别的虚函数，那么f就是虚表的第1项。*/
• } 
• (2)MSVC使用另一种实现 
• int main() 
• { 
•     C c1(1212); 
•     C c2(326); 
•     typedef void (__stdcall* virtual_function)(void); 
• // msvc 通过ecx传递this， 所以参数列表和虚函数相同
• // 同时， msvc生成的虚函数， 会平衡堆栈
• // 所以这里使用 __stdcall  让调用者不做堆栈的平衡工作
• struct { 
•         virtual_function* vptr; 
• int i; 
•     } caster; 
• // 这同样是对编译器生成代码的一种假设和依赖
•     memcpy(&caster,&c1,sizeof(caster)); 
•     printf("c1.i_ = %d/n",caster.i);    // 1212
•     virtual_function* vptr1 = caster.vptr; 
•     printf("c1.vptr_ = %p/n"
•         ,reinterpret_cast(reinterpret_cast(vptr1)) ); 
•     memcpy(&caster,&c2,sizeof(caster)); 
•     printf("c2.i_ = %d/n",caster.i);    // 326
•     virtual_function* vptr2 = caster.vptr; 
•     printf("c2.vptr_ = %p/n"
•         ,reinterpret_cast(reinterpret_cast(vptr2)) ); 
•     assert(vptr1==vptr2); 
• // 显然 c1 c2 都是 C，它们的虚指针是相同的
• // 但是， 直接调用是不行的， 因为没传递this
• //vptr1[2]();
• // 这样也不行
• //_asm { lea ecx, c1 }
• // 因为下面这行代码， 修改了 ecx
• // vptr1[2]();
• // 所以要如下进行直接调用
•     virtual_function f1 = vptr1[1]; 
•     _asm { 
•         lea ecx,c1 
•         call f1 
•     } 
•     virtual_function f2 = vptr2[1]; 
•     _asm { 
•         lea ecx,c2 
•         call f2 
•     } 
• // 分别打印出 C::f(1212),C::f(326)
• // 同时， C::f在虚表的第1项， vs的watch窗口说的 ……
• } 
• 返回页首 
• (八)引用的实现机理 
•         引用的工作方式是什么呢 不纠缠于语法的解释，看代码和汇编结果最直接。举下面这个小例子程序:(gcc -masm=hello -S main.cpp可以得到汇编代码) 
• #include
• int x=3; 
• int f1(){return x;} 
• int& f2(){return x;} 
• int main(){ 
• int a=f1(); 
• int y=f2(); 
• y=4;//仍然有x=3
• int&z=f2(); 
• z=5; 
• printf("x=%d,y=%d",x,y);//z改变了x
• return 0; 
• } 
• 输出是什么呢? x=5,y=4 
• 分析: 
• f2是个返回引用的函数，当且仅当int&z =f2()的时候才是真的返回引用,int y=f2()返回的仍然是一个值的拷贝。汇编代码如下(部分) 
• ----------------------------------------------------------------------------------- 
• f1和f2的定义: 
• .globl __Z2f1v 
• .def __Z2f1v; .scl 2; .type 32; .endef 
• __Z2f1v: 
• push ebp 
• mov ebp, esp 
• mov eax, DWORD PTR _x              f1()返回一个值的拷贝 
• pop ebp 
• ret 
• .align 2 
• .globl __Z2f2v 
• .def __Z2f2v; .scl 2; .type 32; .endef 
• __Z2f2v: 
• push ebp 
• mov ebp, esp 
• mov eax, OFFSET FLAT:_x             f2()返回的就是一个地址，不是值 
• pop ebp 
• ret 
• .def ___main; .scl 2; .type 32; .endef 
• .section .rdata,"dr"
• 我们看一下main函数 
• _main: 
• push ebp 
• mov ebp, esp 
• sub esp, 40 
• and esp, -16 
• mov eax, 0 
• add eax, 15 
• add eax, 15 
• shr eax, 4 
• sal eax, 4 
• mov DWORD PTR [ebp-16], eax 
• mov eax, DWORD PTR [ebp-16] 
• call __alloca 
• call ___main 
• call __Z2f1v                                 -> 调用f1(), 返回值放在eax 
• mov DWORD PTR [ebp-4], eax      -> eax赋值给a 
• call __Z2f2v 
• mov eax, DWORD PTR [eax]         -> 调用f2(), 返回x的值拷贝放在eax 
• mov DWORD PTR [ebp-8], eax     ->  eax赋值给y 
• mov DWORD PTR [ebp-8], 4         ->  立即数"4"赋值给y. y的改变不会改变x!!!!!! 
• call __Z2f2v 
• mov DWORD PTR [ebp-12], eax   -> 调用f2(), 返回x的地址给z 
• mov eax, DWORD PTR [ebp-12]   -> x的地址放入eax 
• mov DWORD PTR [eax], 5            -> 赋值5给eax指向的地址x 
• mov eax, DWORD PTR [ebp-8]    //以下是printf的调用
• mov DWORD PTR [esp+8], eax 
• mov eax, DWORD PTR _x 
• mov DWORD PTR [esp+4], eax 
• mov DWORD PTR [esp], OFFSET FLAT:LC0 
• call _printf 
• mov eax, 0 
• leave 
• ret 
• .def _printf; .scl 2; .type 32; .endef 
• 返回页首 
• (九)虚拟继承有什么样子的内存模型 
•         研究了一下虚拟继承时，对象的内存分布模型，写了下面这个小程序 
• #include
• struct A {int x;int y; }; 
• struct B : virtual public A { 
• int a; 
• B(){x=1;y=2;a=55;} 
• }; 
• struct C : virtual public A { 
• int b; 
• C(){x=3;y=4;b=66;} 
• }; 
• struct D : public B, public C { }; 
• int main(void) { 
• A a; 
• B b; 
• C c; 
• D d; 
• D *pd = &d; 
• C *pd_c =(C*)(&d); 
• B *pd_b =(B*)(&d); 
• A *pd_a =(A*)(&d); 
• printf("%d,%d,%d,%d/n",sizeof(a),sizeof(b),sizeof(c),sizeof(d)); 
• printf("%p,%p,%p,%p/n",pd,pd_c,pd_b,pd_a); 
• int *pd2=(int*)pd; 
• printf("%p,%d,%p,%d,%d,%d/n",**((int**)(pd2)),*(pd2+1),**((int**)(pd2+2)),*(pd2+3),*(pd2+4),*(pd2+5)); 
• return 0; 
• } 
• 输出 
• 8,16,16,24 
• 0022FF20,0022FF28,0022FF20,0022FF30 
• 00000008,55,00000000,66,3,4 
•         结论:D的内存分布像是这样(堆栈从高到低),vbptr表示虚基类量偏移指针 
• |A.y| 
• |A.x| 
• |C.b| 
• |C.vbptr| 
• |B.a| 
• |B.vbptr| 
• 其中bvptr是virtual public类型的对象中，虚基类的偏移量。这里C.vbptr=0,B.vbptr=8.对于d来说，C::C()在B::B()之后调用，所以(x,y)=(3,4) 
• 因此按顺序输出D的内存内容就得到(8,55,0,66,3,4) 
• 返回页首 
• (十)混合编程时的初始化顺序 
• (1)ctor,dtor和atexit的调用顺序 
• #include
• #include
• class a{ 
• int ii; 
• public: 
• explicit a(int i){ 
•     ++count; 
•     ii=i; 
•     printf("ctor i=%d/n",ii); 
•     atexit(f); 
•   } 
•   ~a(){printf("dtor i=%d/n",ii);} 
• static void f(){printf("f() count=%d/n",count);} 
• static int count; 
• }; 
• int a::count=0; 
• void g(){ 
•   a a2(2);//注意，如果a对象声明在一个循环中，那么循环执行N次a的构造函数就会调用N次!!
•   printf("after g() a ctor/n"); 
• } 
• a a3(3);//最外层的对象
• int main(void){ 
•   a a1(1);//次外层的对象
•   atexit(g); 
• return 0; 
• } 
• 运行输出 
• ./a.out
• ctor i=3 
• ctor i=1 
• dtor i=1 
• ctor i=2 
• after g() a ctor 
• dtor i=2 
• f() count=3 
• f() count=3 
• dtor i=3 
• f() count=3 
• (2)一个程序本质上都是由 bss段、data段、text段三个组成的。这样的概念，不知道最初来源于哪里的规定，但在当前的计算机程序设计中是很重要的一个基本概念。而且在嵌入式系统的设计中也非常重要，牵涉到嵌入式系统运行时的内存大小分配，存储单元占用空间大小的问题。 
•     在采用段式内存管理的架构中（比如intel的80x86系统），bss段（Block Started by Symbol segment）通常是指用来存放程序中未初始化的全局变量的一块内存区域，一般在初始化时bss 段部分将会清零。bss段属于静态内存分配，即程序一开始就将其清零了。 
•     比如，在C语言之类的程序编译完成之后，已初始化的全局变量保存在.data 段中，未初始化的全局变量保存在.bss 段中。 
•     在《Programming ground up》里对.bss的解释为：There is another section called the .bss. This section is like the data section, except that it doesn’t take up space in the executable. 
•     text和data段都在可执行文件中（在嵌入式系统里一般是固化在镜像文件中），由系统从可执行文件中加载；而bss段不在可执行文件中，由系统初始化。 
• 例子: (windows+cl) 
• 程序1: 
• int ar[30000]; 
• void main()    ...... 
• 程序2: 
• int ar[300000] =  {1, 2, 3, 4, 5, 6 }; 
• void main()    ...... 
• 发现程序2编译之后所得的.exe文件比程序1的要大得多。发现在程序1.asm中ar的定义如下： 
• _BSS SEGMENT 
•      ?ar@@3PAHA DD 0493e0H DUP (?)    ; ar 
• _BSS ENDS 
• 而在程序2.asm中，ar被定义为： 
• _DATA SEGMENT 
•      ?ar@@3PAHA DD 01H     ; ar 
•                 DD 02H 
•                 DD 03H 
•                 ORG $+1199988 
• _DATA ENDS 
• 区别很明显，一个位于.bss段，而另一个位于.data段，两者的区别在于：全局的未初始化变量存在于.bss段中，具体体现为一个占位符；全局的已初始化变量存于.data段中；而函数内的自动变量(每个编译器都不同，cl是0xCCCCCCCC)都在栈上分配空间。.bss是不占用.exe文件空间的，其内容由操作系统初始化（清零）；而.data却需要占用，其内容由程序初始化，因此造成了上述情况。 
• (3)例子:一个很特殊的strcpy例子，可以让程序崩溃的: 
• #include
• #include
• #include
• void f(char* s){ 
• int len=strlen(s); 
• char buf[len+1]; 
•     strcpy(buf,s); 
•     printf("s=%s,buf=%s/n",s,buf); 
•     strcpy(s,buf); 
•     printf("after strncpy/n"); 
• } 
• int main(void){ 
•         f("abc"); 
• return 0; 
• } 
• ./a.out
• s=abc,buf=abc 
• 段错误 
• 如果我把main函数的内容改为 
• char b[]="abc";//堆栈分配
•         f(b); 
• 运行就没有问题。 
• 原因: “abc”是存在只读属性数据区，不能做strcpy的目的地 
• 数组内存分配在栈上，可作修改，所以数组名可以做strcpy的第一个参数。 
• (4)如果循环里面要用到某个类对象(默认构造函数)，最好把对象的声明移动到循环外面，否则这个对象被初始化的次数就是循环的次数 
• #include
• class c{ 
• public: 
•   c(){printf("ctor/n");} 
• }; 
• int main(void){ 
• int i=10; 
• while(i--){ 
•     c c1; 
•   } 
• return 0; 
• } 
• 运行结果就是"ctor"被打印10次 
• 返回页首 
• (十一)数组和指针的异同 
•     这个是C/C++中最容易混淆，最容易头晕的一个话题。 
•     我们先从一个简单的例子看起(一维数组) 
• void f(char* buf);    |         void f(char* buf); 
• int main(...){        |         int main(...){ 
• char buf[]="abc";       |         char* pbuf="abc"; 
• f(buf);               |         f(pbuf);            ->相同的生成代码 
• buf[2]='x';           |         pbuf[2]='x'         ->不同的生成代码 
• 上面这两个程序有区别吗? 答案是: 
• (1)对于一维数组的处理，传递参数的地时候统统作为指针来看待，也就是f(buf)的调用被编译器等效成了 
• char* pbuf="abc",f(pbuf)这样的调用。 
• (2)对于寻址和赋值: 
• buf[2] 是编译器计算(buf的地址+2)，放入x 
• pbuf[2]是编译器计算pbuf的地址，得到pbuf中的值，再以这个值为基地址，+2，放入x 
• 也就是说，pbuf的赋值语句是2次跳转的，效率比不上buf[2]这样的语句。 
• -------------------------------------------------------------- 
•    考虑复杂一点的情况，**数组怎么办? 
• int main(...){ 
• int buf[2][3];//这个buf数组在内存中仍然是1维连续内存!
• 那么buf[10][10]=6;这样的语句是如何计算的呢? buf的结构被看成一个矩阵被拉直为行向量的表示，10行10列，buf[1][2]的地址就是: 
•    第二行的起始(1*10)+第3个元素的偏移(2)，等效于((int*)(buf))[12]。 
•    这样说很清楚了吧，如果我们要把buf传递给一个函数作为参数，怎么办呢? 只需要保证编译器能看出，这个被拉直的，2维数组，每一行多少个元素: 
• void f(int buf[][10]){ 
•      buf[1][2]=6;//编译器能够通过f的形式参数声明来决定buf[1][2]是从buf偏移多少。
•    ... 
• 上面这个声明和void f(int buf[10][10])甚至void f(int buf[20][10])是等效的。因为我们只需要知道每行包括多少个元素，至于有多少行，(数组多大)，不是编译器控制的，是程序元的责任。 
• -------------------------------------------------------------- 
•     如果f的声明是f(int buf[][])呢? 它等效于f(int *buf[])或者f(int ** ppbuf)这样的声明，传入参数必须是一个真正的2维数组。像下面这样 
• int** buf=new int*[10]; 
• for(int i=0;i<10;++i)buf[i]=new int[10]; 
•     f(buf); 
•     buf数组本身必须是一个指针数组，buf[1][2]这样的计算是: 
• (a)计算buf[1]的值 
• (b)这个值是一个地址，指向一个数组，取这个数组的偏移量2中的值。 
• 如果我混用f(int buf[][10])和f(int buf[][])，我就会得到一个编译警告或者错误: 
• void f2(int ppi[][2]){} 
• void f3(int *ppi[2]){} 
• int p2[3][2]={ {1,2},{3,4}, }; 
• f2(p2);正确的用法 
• f3(p2);警告：传递参数 1 (属于 ‘f3’)时在不兼容的指针类型间转换。 
•    由于f3的生成代码是2次跳转，因此传入p2作为参数的时候，会把一个真正的数组元素的值作为地址看待，再次计算一个内存地址偏移量中的值，可能导致程序崩溃。 
•    再看一个程序，看看运行的结果是什么。 
• int main(void) 
• { 
• int arr[2][3] = { 
•         {0,1,3}, 
•         {4,5,6} 
•     }; 
• int i1=(int)arr; 
• int i2=(int)(arr+1); 
•     printf("i2-i1=%d/n",i2-i1); 
•     printf("%x/n",arr+1); 
•     printf("%x/n",*(arr+1)); 
•     printf("%d/n",**(arr+1))); 
• return 0; 
• } 
•         关于这个话题，最好的相关参考文献:《C专家编程》 
• 返回页首 
• (十二)const限定的传递性 
• (1)如何理解复杂const的指针类型定义? 
• char  * const cp; ( * 读成 pointer to ) 等效于const char* p 
• cp is a const pointer to char
• const char * p; 
• p is a pointer to const char; 
• 先向右看, 再向左看, thinking in C++ 说的很清楚了 
• (2)const对于函数声明: 
• 是个很严格的概念，const对象被调的过程必须保证其使用了带const的函数。例如: 
• > cat t.cpp 
• struct a{ 
• int x; 
• bool operator==(const a& ia){return x==ia.x;}//这里是编译不过的!!!!!!!!
• }; 
• bool f(const a& ia, const a& ib){ 
• return ia==ib;//因为这里的==操作了const a&，而operator==没有被定义为const函数
• } 
• int main(int argc, char *argv[]){ 
• return 0; 
• } 
• 问题解决的方案: 
• bool operator==(const a& ia) const {return x==ia.x;} 
• f中被比较的a类对象是const的，传递给operator==函数，函数不能改变它，因此==必须也是const的。 
• 返回页首 
• (十三)数据类型的限定性检查 
• (1)使用C风格的初始化 
• > cat t.cpp 
• #include
• struct e{//结构体有3个成员
• int x; 
• int y; 
•    e& operator=(const e& ie){*this=ie;} 
•    ~e(){} 
• }; 
• int main(void){ 
•    e buf[]={//用两个成员的{}来初始化
•       {1,2}, 
•       {1,3}, 
•       {1,4} 
•    }; 
•    printf("%d %d %d/n",buf[0].y,buf[1].y,buf[2].y); 
• return 0; 
• } 
• 编译没有问题，但是如果增加了e的构造函数，编译就出错。 
• 原因:只有那些没有定义构造函数且所有数据成员全部为public的类，才可以应用C风格的初始化方式（大括号方式），这是为了与C兼容 
• (2)成员函数中的static变量，作用和类的static变量相同 
• #include
• struct B{ 
• void inc(){ 
• static int i=0; 
•     printf("%d/n",++i); 
•   } 
• }; 
• int main(void){ 
•   B b1,b2; 
•   b1.inc(); 
•   b2.inc(); 
• } 
• > ./a.out
• 1 
• 2 
• (3)explicit的作用域 
• class i{ 
• public: 
• int* a;int b;  
•       i(int* x){ printf("ctor/n"); a=x; } 
•       i(const i& ii){printf("copy ctor/n");a=ii.a;}  
• explicit i(){printf("ctor default/n");} 
•       i& operator=(const i& ii){printf("operator/n"); a=ii.a;} 
• };    
• int main(int argc, char *argv[]){ 
•     i i1; 
• int x=20; 
• int *b=&x; 
•     i1=b; 
•     printf("i1.a=%d,p=%d/n",*(i1.a),i1.a); 
• return 0; 
• } 
• 程序像的输出是 
• ctor default
• ctor 
• operator
• i1.a=20,p=2293596 
• 这里int* b=&x被隐式转换成了i的对象i1=b，但是我的无参数构造函数 
• explicit i()...是加了explicit关键字的，为什么仍然编译通过并正确执行呢? 
• 解释: explicit 只对有一个参数（或者有多个参数，但除了第一个，其他参数都有默认值）的构造函数起作用 
• (4)dynamic_cast的有效性: 
• 只要dynamic_cast输入的参数是一个内容正确的左值，哪怕它是其他类型的指针或者引用转型过来的，只要它本身内容正确(指向了正确的虚函数表)，RTTI就能成功。 
• #include
• #include
• #include
• using namespace std; 
• class A{}; 
• class C{ 
• public: 
• virtual void g(){} 
• }; 
• class D:public C{}; 
• int main(int argc, char *argv[]) 
• { 
•     D d ; 
•     A *a=(A*)&d; 
•     C* pa=(C*)a; 
•     C& pc=*pa; 
• try{ 
•         C& pc2=dynamic_cast(pc); 
•         D& pd=dynamic_cast(pc); 
•     }catch(bad_cast){ 
•         printf("bad_cast/n"); 
•     }catch(...){ 
•         printf("other exception/n"); 
•     } 
• return EXIT_SUCCESS; 
• } 
• 程序不会抛出任何异常。如果我把"D d"的声明改为"C d"的声明，"D& pd=dynamic_cast(pc)"就会抛出std::bad_cast异常 
• Plus: 
• dynamic_cast的输入参数如果无效，是指针是返回NULL，是引用时抛出bad_cast异常 
• (5)union里面的struct必须是plain old data,不能含有ctor,dtor,operator=函数 
• (6)#define宏定义的变量，在编译之后消失了，不利于理解程序合调试，因为没有符号存在。C++为了解决这个问题引入了enum类型，这个类型信息在编译时作为const常量存在，编译后仍然存在符号表信息，利于调试。 
• #define MONDAY 1
• class b{ 
• public: 
• const static int i=0;//if not const, compile error
• enum{friday=5};//equal to const int
• }; 
• const char* buf="abc"; 
• int main(void){ 
• buf="xyz"; 
• int x=b::friday; 
• int y=MONDAY; 
• return 0; 
• } 
• Plus: 注意类当中的static变量，如果加const可以在声明时初始化，不加const必须在类声明之外初始化。 
• 返回页首 
• (十四)使用STL时的类型限制 
• (1)自定义迭代器需要注意的问题 
• 下面这个这个程序的目的是，自定义一个迭代器的类型，模仿STL的访问方式，打印数组的全部内容。 
• #include
• #include
• #include
• #include
• #include
• using namespace std; 
• class array{ 
• int * pi; 
• public: 
•    array(){ 
•            pi=new int[5]; 
•            pi[0]=3; 
•            pi[1]=44; 
•            pi[2]=5; 
•            pi[3]=1; 
•            pi[4]=26; 
•    } 
• virtual ~array(){  if(pi){delete[] pi;pi=0;}  } 
• class Iter{//自己实现的一个迭代器
• int* data; 
• public: 
•          Iter(int* i){data=i;} 
•          Iter(){data=0;} 
•          Iter& operator=(const Iter& i){data=i.data;} 
• bool operator!=(const Iter& i){return data!=i.data;} 
• int operator*(){return *data;} 
• void operator++(){++data;} 
• void operator--(){--data;} 
•    }; 
•    Iter begin(){return Iter(π[0]);} 
•    Iter end(){return Iter(π[5]);} 
• }; 
• int main(int argc, char *argv[]) 
• { 
•     array l; 
•     array::Iter it; 
• for(it=l.begin();it!=l.end();++it){cout<<*it<<' ';} 
•     cout<<'/n'; 
• //copy(l.begin(),l.end(),ostream_iterator(cout, "  ")); //不加这一句，运行没有问题
• return 0; 
• } 
• ->问题: 
• 我把上面那行注释了的"copy(l.begin(),l.end(),ostream_iterator(cout, " ")); "变成有效，编译就过不去了 
• ->原因的解释: 
• 因为，用于标准库算法的迭代器内需要定义有五个公有的类型：iterator_category， value_type， difference_type， distance_type， pointer， reference，其方法有两种：（1）手动定义这五个类型（2）从std::iterator继承 
•     引用《C++程序设计（特别版）》里的一句话： 
• “内部类型int *就是int[]的一个迭代器，类型list::iterator是list类的一个迭代器”不是对内部类型没有要求，而是对内部类型的迭代器有一个默认的解释。iterator_traits 有关于指针类型的偏特化版本. 
• (2)ostream_iterator, 传给cout的对象必须能强制转化为基本类型，或者重载<< 
• #include
• #include
• #include
• using namespace std; 
• struct e{    float v;char c;    
• operator float()const {return v;}    
• //operator char() const {return c;}
• //should conflict with operator float() };
• int main(int argc, char *argv[]) 
• {    int l=4;    e p[]={ {1.5,'x'}, {0.5,'a'}, {1.2,'b'}, {0.7,'y'}    };    
• copy(p,p+l,ostream_iterator(cout," "));    
• cout<<'/n';    
• return 0;} 
• 上面的operator float()和operator char()只能用一个，因为互相冲突 
• (3)friend的一个使用场景 
• 例如，要设计一个单线程的简单singleton，我把 ctor，dtor，copyctor,"="重载ctor都声明为private, 用一个静态函数来创建instance。然后由于我只有创建函数没有销毁函数，我使用auto_ptr来声明这个对象，让编译器来完成对象的释放。 
• class s{ 
• static auto_ptr pInst; 
•   s(){} 
•   ~s(){} 
•   s(const s& os){printf("s.copy ctor/n");} 
•   s& operator = (const s& os){printf("s.operator= called/n");} 
• public: 
• static s& getInst(){ 
• if(pInst.get()==0) 
•          pInst.reset(new s()); 
• return *pInst; 
•   } 
• }; 
• auto_ptr s::pInst; 
•     上面这个程序是编译不通过的，因为auto_ptr的析构函数去delete ，而s的析构函数是私有的，因此在s类的最后面我们还需要加上 
•   friend class auto_ptr; 
• 这样的语句才能编译通过。一个替代的解决方案是不使用auto_ptr，而去使用atexit这样的函数注册一个销毁函数，让程序退出时系统自动调用。 
• (4) class Iter:public std::iterator 
• 这样的话就能 
• copy(l.begin(),l.end(),ostream_iterator(cout, "  "));来打印到标准输出 
• 因为: 
•     用于标准库算法的迭代器内需要定义有五个公有的类型：iterator_category， value_type， difference_type， distance_type， pointer， reference，其方法有两种: 
• 1.手动定义这五个类型 
• 2.从std::iterator继承 
• 返回页首 
• (十五)迭代器自身的类型 
•         在用STL编写庞大程序的时候，如何才能知道一个迭代器指向的对象的真正类型呢? 能否把编译时确定的信息(特化的类型)保存下来以后可以用? 我们的法宝是使用一个iterator_traits对象，它是iterator的内置对象，保留了特化的类型。(通过typedef一个通用的名字来做到的) 
• 对于stl::iterator_traits的一个非常好的解释: 它就是得到一系列的typedef来指示iterator指向对象的类型，原文来自http://msdn.microsoft.com/en-us/library/zdxb97eh(VS.80).aspx
• template 
• struct iterator_traits { 
•    typedef typename Iterator::iterator_category iterator_category; 
•    typedef typename Iterator::value_type value_type; 
•    typedef typename Iterator::difference_type difference_type; 
•    typedef typename Iterator::pointer pointer; 
•    typedef typename Iterator::reference reference; 
•    }; 
• template 
• struct iterator_traits { 
•    typedef random_access_iterator_tag iterator_category;//那种类型的迭代器
•    typedef Type value_type;//--------------->最关键的地方!!!!保存类型信息!!!!
•    typedef ptrdiff_t difference_type; 
•    typedef Type *pointer; 
•    typedef Type& reference; 
•    }; 
• template 
• struct iterator_traits { 
•    typedef random_access_iterator_tag iterator_category; 
•    typedef Type value_type; 
•    typedef ptrdiff_t difference_type; 
•    typedef const Type *pointer; 
•    typedef const Type& reference; 
•    }; 
• 例子程序 
• // iterator_traits.cpp
• // compile with: /EHsc(该选项仅对于VC编译器)
• #include
• #include
• #include
• #include
• using namespace std; 
• template< class it > 
• void
• function( it i1, it i2 ) 
• { 
•    iterator_traits::iterator_category cat; 
•    cout << typeid( cat ).name( ) << endl; 
• while ( i1 != i2 ) 
•    { 
•       iterator_traits::value_type x; 
•       x = *i1; 
•       cout << x << " "; 
•       i1++; 
•    };   
•    cout << endl; 
• }; 
• int main( ) 
• { 
•    vector vc( 10,'a' ); 
•    list li( 10 ); 
•    function( vc.begin( ), vc.end( ) ); 
•    function( li.begin( ), li.end( ) ); 
• } 
• Output: 
• struct std::random_access_iterator_tag 
• a a a a a a a a a a 
• struct std::bidirectional_iterator_tag 
• 0 0 0 0 0 0 0 0 0 0 
• Plus: 
•    iterator不但可以用来访问元素，也可以用于赋值 
• typedef vector vi; 
• vi v(3); 
• vi::iterator it=v.begin(); 
• for(it;it!=v.end();++it)*it=9; 
• copy(v.begin(),v.end(),ostream_iterator(cout,"_")); 
• 返回页首 
• (十六)运行时的类型信息 
• (1)typeid的作用，可以得到动态运行时的信息(对于多态类) 
• >cat type.cpp 
• #include
• using namespace std; 
• class Base { 
• public: 
• virtual void vvfunc() {} 
• }; 
• class Derived : public Base {}; 
• using namespace std; 
• int main() { 
•    Derived* pd = new Derived; 
•    Base* pb = pd; 
•    cout << typeid( pb ).name() << endl;   //prints "class Base *"   静态信息
•    cout << typeid( *pb ).name() << endl;   //prints "class Derived" 动态信息
•    cout << typeid( pd ).name() << endl;   //prints "class Derived *"静态信息
•    cout << typeid( *pd ).name() << endl;   //prints "class Derived" 动态信息
•    delete pd; 
• } 
• 在solaris上面CC的输出结果是 
• > ./a.out
• Base* 
• Derived 
• Derived* 
• Derived 
• typeid 将返回一个派生类的type_info引用。但是expression必须指向一个多态类，否则返回的将是静态类信息。此外，指针必须被提领，以便使用它所指向的对象，没有提领指针，结果将是指针的type_info（这是一个静态信息），而不是它所指向的对象的type_info 
• (2)static_cast能够处理类型运算符重载并解析 
• 一个类，重载(char*)强制类型转换运算符，当我使用static_cast()的时候，该重载仍然是有效的。 
• #include
• #include
• #include
• using namespace std; 
• struct s{ 
• char buf[4]; 
•       s(){strcpy(buf,"abc");} 
• operator char*(){return "kkk";} 
• }; 
• struct c{ 
• char *buf; 
•       c(){buf="xyz";} 
• }; 
• int main(void){ 
•     s s1; 
•     printf("string1 =%s/n",&s1);//打印字符串，效果同s.buf
•     c c1; 
•     printf("string2 =%s/n",*((char**)&c1));//打印字符串
•     printf("string3 =%s/n",(char*)s1); 
•     cout<(s1)<<'/n';//这里，重载的(char*)起了作用
• return 0; 
• } 
• (3)虚函数表的存储结构研究: 
• #include
• class B{//对于含有虚函数的类，内存结构中的首元素是指向虚表的指针。
• int x; 
• virtual void f(){printf("f/n");} 
• virtual void g(){printf("g/n");} 
• virtual void h(){printf("h/n");} 
• public: 
• explicit B(int i) {x=i;} 
• }; 
• typedef void (*pf)(); 
• int main(void){ 
•   B b(20); 
• int * pb=(int*)&b; 
•   printf("private x=%d/n",pb[1]); 
•   pf *pvt=(pf*)pb[0];//虚函数表指针是b的第一个元素，它指向一个保存指针的表
•   pf f1=(pf)pvt[0]; 
•   pf f2=(pf)pvt[1]; 
•   pf f3=(pf)pvt[2]; 
•   (*f1)(); 
•   (*f2)(); 
•   (*f3)(); 
•   printf("pvt[3]=%d/n",pvt[3]);//虚函数表结束符号，gcc是0
• return 0; 
• } 
• 程序输出 
• private x=20 
• f 
• g 
• h 
• pvt[3]=0 
• 返回页首 
• (十七)new/delete重载 
• (1)new和delete运算符的重载，可以用来跟踪代码中内存申请和释放的过程。 
• 下面的例子是重载类中的new和delete 
• class a{ 
• public: 
• void* operator new(size_t){ 
•              printf("a::new/n"); 
• return ::new a; 
•        } 
• void* operator new[](size_t l){ 
•              printf("a::new[%d]/n",l); 
• return ::new a[l]; 
•        } 
• void operator delete(void* p){ 
•              printf("a::delete/n"); 
•              ::delete (a*)p; 
•        } 
• void operator delete[](void* p){ 
•              printf("a::delete[]/n"); 
•              ::delete[] (a*)p; 
•        } 
• }; 
• int main(void){ 
•    a* pa=new a; 
•    delete pa; 
•    pa=new a[2]; 
•    delete[] pa;  
• return 0; 
• } 
• 输出 
• > CC t.C && ./a.out
• a::new
• a::delete 
• a::new[2] 
• a::delete[] 
• (2)replacement new需要注意的地方。例如 
• class c{ 
• int x; 
• public: 
• explicit c(int ix){x=ix;printf("ctor/n");} 
•    ~c(){printf("dtor/n");} 
• }; 
• int main(void){ 
• try{ 
• char mem[sizeof(c)*2]; 
•       c* pc1=new(mem) c(2); 
•       c c3(4); //加上这句以后，delete pc1就是非法退出, 不加这句就没事...........................................
•       delete pc1;//不能去delete内存池中的东西，否则出错 ????????
• //pc1->~c();//用显示调用析构函数而不用delete总是安全的。
•    }catch(...){ 
•       printf("get exception/n"); 
•    } 
• return 0; 
• } 
• 上面的c* pc1=new(mem) c(2); 
• 和delete pc1;//不能去delete内存池中的东西，否则出错 ????????
• 这种方式就是错误的，因为你用的是new的放置语法，而放置语法要求显式的调用析构函数，同时不用的内存需要自己释放时可以free掉，但是在堆栈上的自己费心。更多详细资料可以问问《C++程序设计语言（特别版）第2版》 
• (3)在很多实现中，不考虑构造和析构的话,new/malloc，delete/free是等效的，举VC的例子 
• #if !_VC6SP2 || _DLL
• void *__CRTDECL operator new[](size_t count) _THROW1(std::bad_alloc) 
•         {        // try to allocate count bytes for an array
• return (operator new(count)); 
•         } 
• #endif /* !_VC6SP2 || _DLL */
• _C_LIB_DECL 
• int __cdecl _callnewh(size_t size) _THROW1(_STD bad_alloc); 
• _END_C_LIB_DECL 
• void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) 
•         {       // try to allocate size bytes
• void *p; 
• while ((p = malloc(size)) == 0) 
• if (_callnewh(size) == 0) 
•                 {       // report no memory
• static const std::bad_alloc nomem; 
•                 _RAISE(nomem); 
•                 } 
• return (p); 
•         } 
• (4)在重载的operator new调用的时候，如果分配的是有析构函数的对象数组，那么传进来的size_t会多出一个整数字节的大小，用于记录数组大小(delete[] 需要循环调用各对象的析构函数) 
• 下面这个小程序是重载全局的new/delete操作符来实现对象的分配和释放: 
• #include
• #include
• #include
• using namespace std; 
• void* operator new(size_t size) throw(bad_alloc) 
• { 
• printf("operator new:%d Byte/n",size); 
• void* m=  malloc(size); 
• if(!m) puts("out of memory"); 
• return m; 
• } 
• void operator delete(void* m)throw(){ 
• puts("operator delete"); 
• free(m);} 
• class B{ 
• int s; 
• public: 
• B(){/*puts("B::B()");*/} 
• ~B(){/*puts("B::~B()");*/} 
• }; 
• int main(int argc, char* argv[]){ 
• int* p = new int(4); 
• delete p; 
• B* s = new B; 
• delete s; 
• B* sa = new B[10]; 
• delete []sa; 
• int* pi=new int[3]; 
• delete []pi; 
• return 0; 
• } 
• 程序的输出是 
• > gcc n.C && ./a.out
• operator new:4 Byte 
• operator delete 
• operator new:4 Byte 
• operator delete 
• operator new:48 Byte         ->问题出在这里，new为类指针数组分配的时候，4x10应该是10个字节，多出来的8个字节是做什么的? 
• operator new:12 Byte 
• 回答: 
• 是编译的时候就做到了. 
• 如: 
• class B xxxxxxxxxxxxx; 
•     p=new B[num]; 
• 那么编译器会处理成(注意:不同的编译器会有所不同): 
•   +--------------------------------------------------------------+ 
•    |num|var[0]|var[1]|var[2]|var[3]|........|var[num-1]| 
•   +--------------------------------------------------------------+ 
•         push        n               ;n=num*var_size+4 
•         call           我重载的new
•         .................................... 
•         push        B::~B()的地址 
•         push        B::B()的地址 
•         *((int*)p)=num; 
•         ((int*)p)++; 
•         push        num 
•         push        var_size      
•         push    p 
•         call          vector_constructor_iterator  ;这里会循环调用B::B(),次数是num 
•   +--------------------------------------------------------------+ 
• 对类类型，delete一个数组时（比如，delete []sa;)，要为每一个数组元素调用析构函数。但对于delete表达式（比如，这里的delete []sa），它并不知道数组的元素个数（只有new函数和delete函数知道）。因此，必须有一种手段来告诉delete表达式的数组大小是多少。那么一种可行的方式就是，多分配一个大小为4字节的空间来记录数组大小，并可以约定前四字节来记录大小。那么，由new函数分配的地址与new表达式返回的地址应该相差4个字节（这可以写程序来验证）。对于非类类型数组和不需要调用析构函数的类类型数组，这多于的四字节就不需要了。 
• (5)同理，可以重载全局的new/delete，形如 
• void* operator new( size_t size ){ 
• if( 0 == size ) // 注意!!!!
•         size = 1; 
• while(1){ 
•         分配size字节内存; 
• if(分配成功) 
• return 指向内存的指针; 
•         new_handler g= set_new_handler(0); 
•         set_new_handler(g); 
• if( g)(*g)(); 
• else throw std::bad_alloc(); 
•     } 
• } 
• void operator delete( void* p){ 
• if( 0 == p) // 须要注意
• return; 
•     ... 
• } 
• 上面的new_handler是用户自定义的全局set_new_handler处理函数，newhandler形式是： 
• void mynewhandler(){ 
• if( 使得operator new成功 ) 
•         { 
•             例如等待一段时间，再次分配内存 
• return; 
•         } 
• // 主动退出
•         或 abort/exit 直接退出程序 
•         或 set_new_handler(其他newhandler或者0); 
•         或 set_new_handler(0) 
•         或 throw bad_alloc()//比较好
• } 
• 返回页首 
• (十八)如何拷贝一个文件----标准C/C++运行库里面没有拷贝文件的函数，必须自己完成 
• (1)标准c的逐字节拷贝 
• #include
• int main(void){ 
•   FILE* pin=fopen("in.data","rb"); 
•   FILE* pout=fopen("out.data","wb"); 
• int c; 
• while((c=fgetc(pin))!=EOF){ 
•     fputc(c,pout);} 
•   fclose(pin); 
•   fclose(pout); 
• return 0; 
• } 
• (2)Iostream的多字节拷贝 
• #include
• #include
• using namespace std; 
• int main(void){ 
•   ifstream fi; 
•   fi.open("in.data",ios::binary); 
•   ofstream fo; 
•   fo.open("out.data",ios::binary); 
• char buf[1024]; 
• do{ 
•     fi.read(buf,sizeof(buf)); 
•     fo.write(buf,fi.gcount()); 
•   }while(fi.good()); 
•   fi.close(); 
•   fo.close(); 
• return 0; 
• } 
• 可以把do-while的循环用一句话代替: fo<
• (3)STL算法拷贝，逐字节进行 
• #include
• #include
• #include
• using namespace std; 
• int main(void){ 
•   ifstream fi; 
•   fi.open("in.data",ios::binary); 
•   ofstream fo; 
•   fo.open("out.data",ios::binary); 
•   copy(istreambuf_iterator(fi),istreambuf_iterator(),ostreambuf_iterator(fo)); 
•   fi.close(); 
•   fo.close(); 
• return 0; 
• }