life is live

有下面的一个简单的类： class CNullPointCall
{
public:
    static void Test1();
    void Test2();
    void Test3(int iTest);
    void Test4();

private:
    static int m_iStatic;
    int m_iTest;
};

int CNullPointCall::m_iStatic = 0;

void CNullPointCall::Test1()
{
    cout << m_iStatic << endl;
}

void CNullPointCall::Test2()
{
    cout << "Very Cool!" << endl;
}

void CNullPointCall::Test3(int iTest)
{
    cout << iTest << endl;
}

void CNullPointCall::Test4()
{
    cout << m_iTest << endl;
}
    那么下面的代码都正确吗？都会输出什么？

CNullPointCall *pNull = NULL; // 没错，就是给指针赋值为空
pNull->Test1(); // call 1
pNull->Test2(); // call 2
pNull->Test3(13); // call 3
pNull->Test4(); // call 4
    你肯定会很奇怪我为什么这么问。一个值为NULL的指针怎么可以用来调用类的成员函数呢？！可是实事却很让人吃惊：除了call 4那行代码以外，其余3个类成员函数的调用都是成功的，都能正确的输出结果，而且包含这3行代码的程序能非常好的运行。
    经过细心的比较就可以发现，call 4那行代码跟其他3行代码的本质区别：类CNullPointCall的成员函数中用到了this指针。
    对于类成员函数而言，并不是一个对象对应一个单独的成员函数体，而是此类的所有对象共用这个成员函数体。 当程序被编译之后，此成员函数地址即已确定。而成员函数之所以能把属于此类的各个对象的数据区别开, 就是靠这个this指针。函数体内所有对类数据成员的访问， 都会被转化为this->数据成员的方式。
    而一个对象的this指针并不是对象本身的一部分，不会影响sizeof（“对象”）的结果。this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。
    对于上面的例子来说，this的值也就是pNull的值。也就是说this的值为NULL。而Test1()是静态函数，编译器不会给它传递this指针，所以call 1那行代码可以正确调用（这里相当于CNullPointCall::Test1()）；对于Test2()和Test3()两个成员函数，虽然编译器会给这两个函数传递this指针，但是它们并没有通过this指针来访问类的成员变量，因此call 2和call 3两行代码可以正确调用；而对于成员函数Test4()要访问类的成员变量，因此要使用this指针，这个时候发现this指针的值为NULL，就会造成程序的崩溃。   
    其实，我们可以想象编译器把Test4()转换成如下的形式：

void CNullPointCall::Test4(CNullPointCall *this)
{
    cout << this->m_iTest << endl;
}
    而把call 4那行代码转换成了下面的形式：

CNullPointCall::Test4(pNull);
    所以会在通过this指针访问m_iTest的时候造成程序的崩溃。
    下面通过查看上面代码用VC 2005编译后的汇编代码来详细解释一下神奇的this指针。
    上面的C++代码编译生成的汇编代码是下面的形式：

    CNullPointCall *pNull = NULL;
0041171E mov         dword ptr [pNull],0
    pNull->Test1();
00411725 call        CNullPointCall::Test1 (411069h)
    pNull->Test2();
0041172A mov         ecx,dword ptr [pNull]
0041172D call        CNullPointCall::Test2 (4111E0h)
    pNull->Test3(13);
00411732 push        0Dh
00411734 mov         ecx,dword ptr [pNull]
00411737 call        CNullPointCall::Test3 (41105Ah)
    pNull->Test4();
0041173C mov         ecx,dword ptr [pNull]
0041173F call        CNullPointCall::Test4 (411032h)
    通过比较静态函数Test1()和其他3个非静态函数调用所生成的的汇编代码可以看出：非静态函数调用之前都会把指向对象的指针pNull（也就是this指针）放到ecx寄存器中（mov ecx,dword ptr [pNull]）。这就是this指针的特殊之处。看call 3那行C++代码的汇编代码就可以看到this指针跟一般的函数参数的区别：一般的函数参数是直接压入栈中（push 0Dh），而this指针却被放到了ecx寄存器中。在类的非成员函数中如果要用到类的成员变量，就可以通过访问ecx寄存器来得到指向对象的this指针，然后再通过this指针加上成员变量的偏移量来找到相应的成员变量。
    下面再通过另外一个例子来说明this指针是怎样被传递到成员函数中和如何使用this来访问成员变量的。
    依然是一个很简单的类：

class CTest
{
public:
    void SetValue();

private:
    int m_iValue1;
    int m_iValue2;
};

void CTest::SetValue()
{
    m_iValue1 = 13;
    m_iValue2 = 13;
}

用如下的代码调用成员函数：

CTest test;
test.SetValue();

    上面的C++代码的汇编代码为：

    CTest test;
    test.SetValue();
004117DC lea         ecx,[test]
004117DF call        CTest::SetValue (4111CCh)
    同样的，首先把指向对象的指针放到ecx寄存器中；然后调用类CTest的成员函数SetValue()。地址4111CCh那里存放的其实就是一个转跳指令，转跳到成员函数SetValue()内部。

004111CC jmp         CTest::SetValue (411750h)
    而411750h才是类CTest的成员函数SetValue()的地址。

void CTest::SetValue()
{
00411750 push        ebp
00411751 mov         ebp,esp
00411753 sub         esp,0CCh
00411759 push        ebx
0041175A push        esi
0041175B push        edi
0041175C push        ecx // 1  
0041175D lea         edi,[ebp-0CCh]
00411763 mov         ecx,33h
00411768 mov         eax,0CCCCCCCCh
0041176D rep stos    dword ptr es:[edi]
0041176F pop         ecx // 2
00411770 mov         dword ptr [ebp-8],ecx // 3
    m_iValue1 = 13;
00411773 mov         eax,dword ptr [this] // 4
00411776 mov         dword ptr [eax],0Dh // 5
    m_iValue2 = 13;
0041177C mov         eax,dword ptr [this] // 6
0041177F mov         dword ptr [eax+4],0Dh // 7
}
00411786 pop         edi
00411787 pop         esi
00411788 pop         ebx
00411789 mov         esp,ebp
0041178B pop         ebp
0041178C ret
    下面对上面的汇编代码中的重点行进行分析：
    1、将ecx寄存器中的值压栈，也就是把this指针压栈。
    2、ecx寄存器出栈，也就是this指针出栈。
    3、将ecx的值放到指定的地方，也就是this指针放到[ebp-8]内。
    4、取this指针的值放入eax寄存器内。此时，this指针指向test对象，test对象只有两个int型的成员变量，在test对象内存中连续存放，也就是说this指针目前指向m_iValue1。
    5、给寄存器eax指向的地址赋值0Dh（十六进制的13）。其实就是给成员变量m_iValue1赋值13。
    6、同4。
    7、给寄存器eax指向的地址加4的地址赋值。在4中已经说明，eax寄存器内存放的是this指针，而this指针指向连续存放的int型的成员变量m_iValue1。this指针加4（sizeof(int)）也就是成员变量m_iValue2的地址。因此这一行就是给成员变量m_iValue2赋值。
    通过上面的分析，我们可以从底层了解了C++中this指针的实现方法。虽然不同的编译器会使用不同的处理方法，但是C++编译器必须遵守C++标准，因此对于this指针的实现应该都是差不多的。

new的第三种形态——placement new是用来实现定位构造的，因此可以实现new operator三步操作中的第二步，也就是在取得了一块可以容纳指定类型对象的内存后，在这块内存上构造一个对象，这有点类似于前面代码中的“p->A::A(3);”这句话，但这并不是一个标准的写法，正确的写法是使用placement new：
#include <new.h>

void main()
{
   char s[sizeof(A)];
   A* p = (A*)s;
   new(p) A(3); //p->A::A(3);
   p->Say();
}

在默认情况下，new_handler的行为是抛出一个bad_alloc异常，因此上述循环只会执行一次。但如果我们不希望使用默认行为，可以自定义一个new_handler，并使用std::set_new_handler函数使其生效。在自定义的new_handler中，我们可以抛出异常，可以结束程序，也可以运行一些代码使得有可能有内存被空闲出来，从而下一次分配时也许会成功，也可以通过set_new_handler来安装另一个可能更有效的new_handler。例如：

void MyNewHandler()
{
   printf(“New handler called!\n”);
   throw std::bad_alloc();
}

std::set_new_handler(MyNewHandler);

这里new_handler程序在抛出异常之前会输出一句话。应该注意，在new_handler的代码里应该注意避免再嵌套有对new的调用，因为如果这里调用new再失败的话，可能会再导致对new_handler的调用，从而导致无限递归调用。——这是我猜的，并没有尝试过。

在编程时我们应该注意到对new的调用是有可能有异常被抛出的，因此在new的代码周围应该注意保持其事务性，即不能因为调用new失败抛出异常来导致不正确的程序逻辑或数据结构的出现。例如：

class SomeClass
{
   static int count;
   SomeClass() {}
public:
   static SomeClass* GetNewInstance()
   {
       count++;
       return new SomeClass();
   }
};

静态变量count用于记录此类型生成的实例的个数，在上述代码中，如果因new分配内存失败而抛出异常，那么其实例个数并没有增加，但count变量的值却已经多了一个，从而数据结构被破坏。正确的写法是：

static SomeClass* GetNewInstance()
{
   SomeClass* p = new SomeClass();
   count++;
   return p;
}

这样一来，如果new失败则直接抛出异常，count的值不会增加。类似的，在处理线程同步时，也要注意类似的问题：

void SomeFunc()
{
   lock(someMutex); //加一个锁
   delete p;
   p = new SomeClass();
   unlock(someMutex);
}

此时，如果new失败，unlock将不会被执行，于是不仅造成了一个指向不正确地址的指针p的存在，还将导致someMutex永远不会被解锁。这种情况是要注意避免的。（参考：C++箴言：争取异常安全的代码）

STL的内存分配与traits技巧

在《STL原码剖析》一书中详细分析了SGI STL的内存分配器的行为。与直接使用new operator不同的是，SGI STL并不依赖C++默认的内存分配方式，而是使用一套自行实现的方案。首先SGI STL将可用内存整块的分配，使之成为当前进程可用的内存，当程序中确实需要分配内存时，先从这些已请求好的大内存块中尝试取得内存，如果失败的话再尝试整块的分配大内存。这种做法有效的避免了大量内存碎片的出现，提高了内存管理效率。

为了实现这种方式，STL使用了placement new，通过在自己管理的内存空间上使用placement new来构造对象，以达到原有new operator所具有的功能。

template <class T1, class T2>
inline void construct(T1* p, const T2& value)
{
   new(p) T1(value);
}

此函数接收一个已构造的对象，通过拷贝构造的方式在给定的内存地址p上构造一个新对象，代码中后半截T1(value)便是placement new语法中调用构造函数的写法，如果传入的对象value正是所要求的类型T1，那么这里就相当于调用拷贝构造函数。类似的，因使用了placement new，编译器不会自动产生调用析构函数的代码，需要手工的实现：

template <class T>
inline void destory(T* pointer)
{
   pointer->~T();
}

与此同时，STL中还有一个接收两个迭代器的destory版本，可将某容器上指定范围内的对象全部销毁。典型的实现方式就是通过一个循环来对此范围内的对象逐一调用析构函数。如果所传入的对象是非简单类型，这样做是必要的，但如果传入的是简单类型，或者根本没有必要调用析构函数的自定义类型（例如只包含数个int成员的结构体），那么再逐一调用析构函数是没有必要的，也浪费了时间。为此，STL使用了一种称为“type traits”的技巧，在编译器就判断出所传入的类型是否需要调用析构函数：

template <class ForwardIterator>
inline void destory(ForwardIterator first, ForwardIterator last)
{
   __destory(first, last, value_type(first));
}

其中value_type()用于取出迭代器所指向的对象的类型信息，于是：

template<class ForwardIterator, class T>
inline void __destory(ForwardIterator first, ForwardIterator last, T*)
{
   typedef typename __type_traits<T>::has_trivial_destructor trivial_destructor;
   __destory_aux(first, last, trivial_destructor());
}
//如果需要调用析构函数：
template<class ForwardIterator>
inline void __destory_aux(ForwardIterator first, ForwardIterator last, __false_type)
{
   for(; first < last; ++first)
       destory(&*first); //因first是迭代器，*first取出其真正内容，然后再用&取地址
}
//如果不需要，就什么也不做：
tempalte<class ForwardIterator>
inline void __destory_aux(ForwardIterator first, ForwardIterator last, __true_type)
{}

因上述函数全都是inline的，所以多层的函数调用并不会对性能造成影响，最终编译的结果根据具体的类型就只是一个for循环或者什么都没有。这里的关键在于__type_traits<T>这个模板类上，它根据不同的T类型定义出不同的has_trivial_destructor的结果，如果T是简单类型，就定义为__true_type类型，否则就定义为__false_type类型。其中__true_type、__false_type只不过是两个没有任何内容的类，对程序的执行结果没有什么意义，但在编译器看来它对模板如何特化就具有非常重要的指导意义了，正如上面代码所示的那样。__type_traits<T>也是特化了的一系列模板类：

struct __true_type {};
struct __false_type {};
template <class T>
struct __type_traits
{
public:
   typedef __false _type has_trivial_destructor;
   ……
};
template<> //模板特化
struct __type_traits<int>    //int的特化版本
{
public:
   typedef __true_type has_trivial_destructor;
   ……
};
…… //其他简单类型的特化版本

如果要把一个自定义的类型MyClass也定义为不调用析构函数，只需要相应的定义__type_traits<T>的一个特化版本即可：

template<>
struct __type_traits<MyClass>
{
public:
   typedef __true_type has_trivial_destructor;
   ……
};

模板是比较高级的C++编程技巧，模板特化、模板偏特化就更是技巧性很强的东西，STL中的type_traits充分借助模板特化的功能，实现了在程序编译期通过编译器来决定为每一处调用使用哪个特化版本，于是在不增加编程复杂性的前提下大大提高了程序的运行效率。更详细的内容可参考《STL源码剖析》第二、三章中的相关内容。

带有“[]”的new和delete

我们经常会通过new来动态创建一个数组，例如：

char* s = new char[100];
……
delete s;

严格的说，上述代码是不正确的，因为我们在分配内存时使用的是new[]，而并不是简单的new，但释放内存时却用的是delete。正确的写法是使用delete[]：

delete[] s;

但是，上述错误的代码似乎也能编译执行，并不会带来什么错误。事实上，new与new[]、delete与delete[]是有区别的，特别是当用来操作复杂类型时。假如针对一个我们自定义的类MyClass使用new[]：

MyClass* p = new MyClass[10];

上述代码的结果是在堆上分配了10个连续的MyClass实例，并且已经对它们依次调用了构造函数，于是我们得到了10个可用的对象，这一点与Java、C#有区别的，Java、C#中这样的结果只是得到了10个null。换句话说，使用这种写法时MyClass必须拥有不带参数的构造函数，否则会发现编译期错误，因为编译器无法调用有参数的构造函数。

当这样构造成功后，我们可以再将其释放，释放时使用delete[]：

delete[] p;

当我们对动态分配的数组调用delete[]时，其行为根据所申请的变量类型会有所不同。如果p指向简单类型，如int、char等，其结果只不过是这块内存被回收，此时使用delete[]与delete没有区别，但如果p指向的是复杂类型，delete[]会针对动态分配得到的每个对象调用析构函数，然后再释放内存。因此，如果我们对上述分配得到的p指针直接使用delete来回收，虽然编译期不报什么错误（因为编译器根本看不出来这个指针p是如何分配的），但在运行时（DEBUG情况下）会给出一个Debug assertion failed提示。

到这里，我们很容易提出一个问题——delete[]是如何知道要为多少个对象调用析构函数的？要回答这个问题，我们可以首先看一看new[]的重载。

class MyClass
{
   int a;
public:
   MyClass() { printf("ctor\n"); }
   ~MyClass() { printf("dtor\n"); }
};

void* operator new[](size_t size)
{
   void* p = operator new(size);
   printf("calling new[] with size=%d address=%p\n", size, p);
   return p;
}

// 主函数
MyClass* mc = new MyClass[3];
printf("address of mc=%p\n", mc);
delete[] mc;

运行此段代码，得到的结果为：（VC2005）

calling new[] with size=16 address=003A5A58

ctor

ctor

ctor

address of mc=003A5A5C

dtor

dtor

dtor

虽然对构造函数和析构函数的调用结果都在预料之中，但所申请的内存空间大小以及地址的数值却出现了问题。我们的类MyClass的大小显然是4个字节，并且申请的数组中有3个元素，那么应该一共申请12个字节才对，但事实上系统却为我们申请了16字节，并且在operator new[]返后我们得到的内存地址是实际申请得到的内存地址值加4的结果。也就是说，当为复杂类型动态分配数组时，系统自动在最终得到的内存地址前空出了4个字节，我们有理由相信这4个字节的内容与动态分配数组的长度有关。通过单步跟踪，很容易发现这4个字节对应的int值为0x00000003，也就是说记录的是我们分配的对象的个数。改变一下分配的个数然后再次观察的结果证实了我的想法。于是，我们也有理由认为new[] operator的行为相当于下面的伪代码：

template <class T>
T* New[](int count)
{
   int size = sizeof(T) * count + 4;
   void* p = T::operator new[](size);
   *(int*)p = count;
   T* pt = (T*)((int)p + 4);
   for(int i = 0; i < count; i++)
       new(&pt[i]) T();
   return pt;
}

上述示意性的代码省略了异常处理的部分，只是展示当我们对一个复杂类型使用new[]来动态分配数组时其真正的行为是什么，从中可以看到它分配了比预期多4个字节的内存并用它来保存对象的个数，然后对于后面每一块空间使用placement new来调用无参构造函数，这也就解释了为什么这种情况下类必须有无参构造函数，最后再将首地址返回。类似的，我们很容易写出相应的delete[]的实现代码：

template <class T>
void Delete[](T* pt)
{
   int count = ((int*)pt)[-1];
   for(int i = 0; i < count; i++)
       pt[i].~T();
   void* p = (void*)((int)pt – 4);
   T::operator delete[](p);
}

由此可见，在默认情况下operator new[]与operator new的行为是相同的，operator delete[]与operator delete也是，不同的是new operator与new[] operator、delete operator与delete[] operator。当然，我们可以根据不同的需要来选择重载带有和不带有“[]”的operator new和delete，以满足不同的具体需求。

把前面类MyClass的代码稍做修改——注释掉析构函数，然后再来看看程序的输出：

calling new[] with size=12 address=003A5A58

ctor

ctor

ctor

address of mc=003A5A58

这一次，new[]老老实实的申请了12个字节的内存，并且申请的结果与new[] operator返回的结果也是相同的，看来，是否在前面添加4个字节，只取决于这个类有没有析构函数，当然，这么说并不确切，正确的说法是这个类是否需要调用构造函数，因为如下两种情况下虽然这个类没声明析构函数，但还是多申请了4个字节：一是这个类中拥有需要调用析构函数的成员，二是这个类继承自需要调用析构函数的类。于是，我们可以递归的定义“需要调用析构函数的类”为以下三种情况之一：

1 显式的声明了析构函数的

2 拥有需要调用析构函数的类的成员的

3 继承自需要调用析构函数的类的

类似的，动态申请简单类型的数组时，也不会多申请4个字节。于是在这两种情况下，释放内存时使用delete或delete[]都可以，但为养成良好的习惯，我们还是应该注意只要是动态分配的数组，释放时就使用delete[]。

释放内存时如何知道长度

但这同时又带来了新问题，既然申请无需调用析构函数的类或简单类型的数组时并没有记录个数信息，那么operator delete，或更直接的说free()是如何来回收这块内存的呢？这就要研究malloc()返回的内存的结构了。与new[]类似的是，实际上在malloc()申请内存时也多申请了数个字节的内容，只不过这与所申请的变量的类型没有任何关系，我们从调用malloc时所传入的参数也可以理解这一点——它只接收了要申请的内存的长度，并不关系这块内存用来保存什么类型。下面运行这样一段代码做个实验：

char *p = 0;
for(int i = 0; i < 40; i += 4)
{
   char* s = new char[i];
   printf("alloc %2d bytes, address=%p distance=%d\n", i, s, s - p);
   p = s;
}

我们直接来看VC2005下Release版本的运行结果，DEBUG版因包含了较多的调试信息，这里就不分析了：

alloc 0 bytes, address=003A36F0 distance=3815152

alloc 4 bytes, address=003A3700 distance=16

alloc 8 bytes, address=003A3710 distance=16

alloc 12 bytes, address=003A3720 distance=16

alloc 16 bytes, address=003A3738 distance=24

alloc 20 bytes, address=003A84C0 distance=19848

alloc 24 bytes, address=003A84E0 distance=32

alloc 28 bytes, address=003A8500 distance=32

alloc 32 bytes, address=003A8528 distance=40

alloc 36 bytes, address=003A8550 distance=40

每一次分配的字节数都比上一次多4，distance值记录着与上一次分配的差值，第一个差值没有实际意义，中间有一个较大的差值，可能是这块内存已经被分配了，于是也忽略它。结果中最小的差值为16字节，直到我们申请16字节时，这个差值变成了24，后面也有类似的规律，那么我们可以认为申请所得的内存结构是如下这样的：

从图中不难看出，当我们要分配一段内存时，所得的内存地址和上一次的尾地址至少要相距8个字节（在DEBUG版中还要更多），那么我们可以猜想，这8个字节中应该记录着与这段所分配的内存有关的信息。观察这8个节内的内容，得到结果如下：

图中右边为每次分配所得的地址之前8个字节的内容的16进制表示，从图中红线所表示可以看到，这8个字节中的第一个字节乘以8即得到相临两次分配时的距离，经过试验一次性分配更大的长度可知，第二个字节也是这个意义，并且代表高8位，也就说前面空的这8个字节中的前两个字节记录了一次分配内存的长度信息，后面的六个字节可能与空闲内存链表的信息有关，在翻译内存时用来提供必要的信息。这就解答了前面提出的问题，原来C/C++在分配内存时已经记录了足够充分的信息用于回收内存，只不过我们平常不关心它罢了。