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

(一)整数符号的陷阱 
(二)浮点数的本质 
(三)堆栈的内存管理结构 
(四)符号解析 
(五)对齐和总线错误 
(六)函数指针 
(七)虚函数的实现机理 
(八)引用的实现机理 
(九)虚拟继承对象的内存结构 
(十)混合编程时的初始化顺序 
(十一)数组和指针的异同 
(十二)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 ",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 ",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 ",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 "); 
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(" "); 
  printf("end loop "); 
} 
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 ",i,f); 
  printf("%f ",f1+f2+f3); 
  printf("%f ",f2+f3+f1); 
    上面两个printf的结果是不一样的，第一个结果是0，第二个结果是3.14。再举一个例子 
float k=1.3456789; 
float k2=k; 
  k-=1000000.0; 
  printf("%f ",k); 
  k+=1000000.0; 
  printf("%f ",k); 
int b=(k==k2); 
  printf("%d ",b); 
    结果是什么呢? b=0，因为k的值在之前的运算中，小数点后面已经有5为被舍入了，所以k不再等于k2。要使得k==k2成立，必须提高京都，使用double--52位整数域，相当于10进制有效数字16位，可以克服上面这个运算的不精确性。 
double d1,d2; 
  printf("%f ",d1); 
  d1=d2=1.3456789; 
  d2+=1000000.0; 
  printf("%f ",d2); 
  d2-=1000000.0; 
  printf("%f ",d2); 
        现在d==d2的返回值就是真了。为了使得运算结果有可以比较的意义，通常定义一个门限值。#define fequals(a,b) fabs(a-b)<0.01f 
        如果浮点数计算溢出，printf能够输出适当的表示 
float nan=3.0f/0.0f; 
  printf("%f ",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 ",x,y,z); 
printf("%p,%p,%p ",px,py,pz); 
printf("%d,%d,%d ",*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 ",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 ",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 ",*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 ");} 
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 ");} 
virtual void g(){printf("g ");} 
virtual void h(){printf("h ");} 
public: 
explicit B(int i) {x=i;} 
}; 
typedef void (*pf)(); 
int main(void){ 
  B b(20); 
int * pb=(int*)&b; 
  printf("private x=%d ",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 ",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 ",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 ",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) ",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 ",caster.i); // 1212
    printf("c1.vptr_ = %p "
        ,reinterpret_cast(reinterpret_cast(caster.vptr)) ); 
    virtual_function* vptr1 = caster.vptr; 
    memcpy(&caster,&c2,sizeof(caster)); 
    printf("c2.i_ = %d ",caster.i); 
    printf("c2.vptr_ = %p ",(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 ",caster.i);    // 1212
    virtual_function* vptr1 = caster.vptr; 
    printf("c1.vptr_ = %p "
        ,reinterpret_cast(reinterpret_cast(vptr1)) ); 
    memcpy(&caster,&c2,sizeof(caster)); 
    printf("c2.i_ = %d ",caster.i);    // 326
    virtual_function* vptr2 = caster.vptr; 
    printf("c2.vptr_ = %p "
        ,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 ",sizeof(a),sizeof(b),sizeof(c),sizeof(d)); 
printf("%p,%p,%p,%p ",pd,pd_c,pd_b,pd_a); 
int *pd2=(int*)pd; 
printf("%p,%d,%p,%d,%d,%d ",**((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 ",ii); 
    atexit(f); 
  } 
  ~a(){printf("dtor i=%d ",ii);} 
static void f(){printf("f() count=%d ",count);} 
static int count; 
}; 
int a::count=0; 
void g(){ 
  a a2(2);//注意，如果a对象声明在一个循环中，那么循环执行N次a的构造函数就会调用N次!!
  printf("after g() a ctor "); 
} 
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 ",s,buf); 
    strcpy(s,buf); 
    printf("after strncpy "); 
} 
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 ");} 
}; 
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 ",i2-i1); 
    printf("%x ",arr+1); 
    printf("%x ",*(arr+1)); 
    printf("%d ",**(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 ",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 ",++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 "); a=x; } 
      i(const i& ii){printf("copy ctor ");a=ii.a;}  
explicit i(){printf("ctor default ");} 
      i& operator=(const i& ii){printf("operator "); 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 ",*(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 "); 
    }catch(...){ 
        printf("other exception "); 
    } 
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<<' '; 
//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<<' ';    
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 ");} 
  s& operator = (const s& os){printf("s.operator= called ");} 
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 ",&s1);//打印字符串，效果同s.buf
    c c1; 
    printf("string2 =%s ",*((char**)&c1));//打印字符串
    printf("string3 =%s ",(char*)s1); 
    cout<(s1)<<' ';//这里，重载的(char*)起了作用
return 0; 
} 
(3)虚函数表的存储结构研究: 
#include
class B{//对于含有虚函数的类，内存结构中的首元素是指向虚表的指针。
int x; 
virtual void f(){printf("f ");} 
virtual void g(){printf("g ");} 
virtual void h(){printf("h ");} 
public: 
explicit B(int i) {x=i;} 
}; 
typedef void (*pf)(); 
int main(void){ 
  B b(20); 
int * pb=(int*)&b; 
  printf("private x=%d ",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 ",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 "); 
return ::new a; 
       } 
void* operator new[](size_t l){ 
             printf("a::new[%d] ",l); 
return ::new a[l]; 
       } 
void operator delete(void* p){ 
             printf("a::delete "); 
             ::delete (a*)p; 
       } 
void operator delete[](void* p){ 
             printf("a::delete[] "); 
             ::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 ");} 
   ~c(){printf("dtor ");} 
}; 
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 "); 
   } 
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 ",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; 
}
本篇文章来源于：开发学院 http://edu.codepub.com   原文链接：http://edu.codepub.com/2010/0301/20583.php

原文链接：http://edu.codepub.com/2010/0301/20583.php