如何养成良好的C++编程习惯（一）―― 内存管理 (四)

return m_pch;
}

private:
T* m_pch;
size_t m_size;
size_t m_capacity;
};

// 常用 buffer 类型的 typedef
typedef CBufferPtrT CCharBufferPtr;
typedef CBufferPtrT CWCharBufferPtr;
typedef CBufferPtrT CByteBufferPtr;
typedef CByteBufferPtr CBufferPtr;

#ifdef _UNICODE
typedef CWCharBufferPtr CTCharBufferPtr;
#else
typedef CCharBufferPtr CTCharBufferPtr;
#endif

　　嗯。这里要解释一下为何需要两个拷贝构造函数和赋值操作符重载，首先，编译器为不同的模板参数生成不同的类，也就是说：CBufferPtrT 和 CBufferPtrT 被看作是不同的类，另外，C++ 编译器为每个类提供了提供了拷贝构造函数和赋值操作符重载的默认实现（浅拷贝）。因此，上述的第一组拷贝构造函数和赋值操作符重载是改写编译器的默认实现，第二组拷贝构造函数和赋值操作符重载是处理其它类到本类的转换。
　　本座对这个封装灰常满意（唯一美中不足的就是 cnblogs 的编辑器太坑爹了，把代码弄乱 ^_^），它并非只是一个普通的 malloc() 封装，完全能可以把它看作是一种“支持索引访问的类型安全的动态缓冲区”。如果把它放在一个 socket 通信类中作为成员属性，充当跨越多个线程和多个方法访问的接收缓冲区和发送缓冲区的角色就最适合不过了（当然要自己做同步了）。大家可以调试一下下面的测试例子，了解一下它的用法：

测试用例
1 int _tmain(int argc, _TCHAR* argv[])
2 {
3 CBufferPtr buffer;
4
5 unsigned char c1 = 'X';
6 unsigned char pc1[] = "123";
7 unsigned char pc2[] = "abc";
8 buffer.Cat(&c1);
9 buffer.Cat(pc1, 3);
10 buffer.Cat(pc2, 3);
11
12 CBufferPtrT buffer2 = buffer;
13 buffer2.Cat(buffer);
14 buffer2.Realloc(0);
15
16 unsigned char* pc = buffer;
17 const unsigned char& c = buffer[5];
18 buffer[5] = 'O';
19
20 short i1 = 0x7FFF;
21 short pi0[] = {9,9,9};
22 short pi1[] = {1,2,3};
23 short pi2[] = {4,5,6};
24 short pi3[] = {8,8,8};
25
26 CBufferPtrT bufferS(pi0, 3);
27
28 bufferS.Cat(&i1);
29 bufferS.Cat(pi1, 3);
30 bufferS.Cat(pi2, 3);
31 bufferS.Cat(pi3, 3);
32
33 CBufferPtrT bufferS2;
34 bufferS2.Malloc(4);
35
36 bufferS2 = bufferS;
37 bufferS2.Realloc(30);
38
39 CBufferPtrT bufferI(5, true);
40
41 for(size_t i = 0; i < bufferI.Size(); i++)
42 bufferI[i] = i *10;
43
44 bufferI.Malloc();
45 bufferI[0] = 123;
46
47 // 下面这行编译不通过，正好说明这个类是类型安全的
48 // bufferI = bufferS;
49
50 return 0;
51 }

________________________________________

new & delete
　　一说到 new 的封装大家立马想到的就是智能指针吧！没错，就是智能指针。但 STL 提供的 auto_ptr 缺陷很多，首先使用起来不方便，竟然连这种写法都不支持：“std::auto_ptr pi = new int;”，天理何在啊！更可恨的是不支持数组指针（需要 delete[]），另外如果某些类重载了 new 操作符的话使用它也有很多问题的，还有其它的很多缺点（我忘记了 ^_^）。不过，C++0x 似乎对智能指针作了重大改进，已经有支持引用计数的智能指针了，但不知是否解决数组指针和区分 delete 与 ::delete 的问题（本座没实测，要是您知道麻烦告诉一声 ^_^）。无论如何，下面代码列出的智能指针支持区分 delete / delete[] / ::delete / ::delete[]。算是 auto_ptr 的改良（也没有使用引用计数），文章篇幅太长了，测试用例就不发了，各位看官自行尝试吧：
/************************************************************************/
/* smart_ptr 单实体或数组智能指针 */
/************************************************************************/

template
struct simple_deleter
{
static void delete_ptr(_Ty* pv) {delete pv;}
};

template
struct global_simple_deleter
{
static void delete_ptr(_Ty* pv) {::delete pv;}
};

template
struct array_deleter
{
static void delete_ptr(_Ty* pv) {delete[] pv;}
};

template
struct global_array_deleter
{
static void delete_ptr(_Ty* pv) {::delete[] pv;}
};

template
class smart_ptr
{
public:
smart_ptr(_Ty* _Ptr = 0) : _Myptr(_Ptr) {}
smart_ptr(smart_ptr<_Ty, _Deleter>& _Right) : _Myptr(_Right.release()) {}

~smart_ptr()
{
reset();
}

smart_ptr<_Ty, _Deleter>& reset(_Ty* _Ptr = 0)