《C++应用程序性能优化::第五章动态内存管理》学习和理解
说明：《C++应用程序性能优化》 作者：冯宏华等 2007年版。
2010.8.29
cs_wuyg@126.com
这一章不错，之前对new和delete的理解并不是很深。虽然学C++primer的时候懂一点智能指针，但是没学过boost的智能指针，这书里边都讲到了，找了下资料，很容易理解。这本书适合有一定开发经验的开发人员，我这个还没有开发经验的菜鸟还是能从中获得很多知识。
一、 operator new/delete
C++标准中3.7.3中规定，C++实现通过全局“allocation functions”new/new []和“deallocation functions”delete/delete[]来提供动态内存的访问和管理。
众所周知，new试图分配给定大小size的内存。如果成功，返回获得内存块的起始地址。这里需要指出的是，C++标准中没有规定是否要对获得的内存进行初始化。这意味着，如果开发人员没有显式的对获得的内存赋值，那么它们的初始值完全取决于编译器的实现。
operator new有多种形式，placement new（例如char *p = new(buff) char[100]）可以指定要申请的空间在哪个地方（就在buff里）。
应用程序必须处理内存分配失败的情况。通过可以通过捕获std::bad_alloc异常或者返回值检查内存分配是否成功，而更好的方法是使用C++中的new_handler()函数。
C++标准中对内存分配失败有明确的规定，系统会调用当前安装的new_handler()函数。这个错误处理函数是通过set_new_handler()安装到系统上的，C++规定new_handler要执行下列操作中的一种：
（1） 使new操作有更多的内存可用，然后返回
（2） 抛出一个bad_alloc或其派生的异常
（3） 调用abort()或者exit()退出。
二、 自定义operator new/delete
当应用程序需要用同一的机制来控制数据的内存分配情况，并且不想使用系统提供的内存管理机制时，可以通过重写自己的全局operator new/delete来实现。一般对于一些内存要求较高的应用程序可能会采用这种方式。此外，有时为了调试内存分配情况，也会实现全局的operator new/delete，增加一些特殊处理，如产生log等来方便调试和排错。《Effective C++》中指出，自己重写operator new/delete时，很重要的一点就是函数提供的行为要和系统默认的operator new一致。
当自定义全局的operator new/delete时，程序中的所有内存分配释放将使用统一的方式。然而在某些情况下，程序希望创建不同的类对象时使用不同的内存分配方式，尤其是在一些要求内存分配效率的程序中。为此，可以通过类成员函数形式的operator new/delete重载来为一些特定的类实现这个类自己的operator new/delete，而其他则保持使用系统默认的operator new/delete。在实际开发中，如果要自定义operator new，最好也要实现自定义delete。
当某个类自定义了operator new/delete，它的派生类也会默认继承使用基类自定义的operator new/delete。如果想让派生类使用全局的new/delete，那么可以在基类的operator new中判断参数的大小，当是基类的时候就使用自定义的，当不是基类的时候就是用全局的。也可以通过另一种方式实现，让派生类重写operator new，在重写的函数里边调用全局的new。
三、 避免内存泄漏
一个复杂的C++程序中最容易出现的问题是内存泄漏。即是忘记释放申请的内存，造成程序占用的内存不断上升，系统性能会不断下降，甚至会内存耗尽而导致程序崩溃。相比java，C++没有自动的垃圾回收，但是C++语言还是提供了足够强大和灵活的机制。可以将new和delete操作封装到一个类里边，在构造时分配内存，在析构时释放内存，这样就不会有内存泄漏（资源申请、释放跟构造、析构绑定，这是RAII：resource acquisition is initialization）。
把new和delete操作封装到类里边，要考虑到拷贝构造函数和重载赋值操作的问题，因此还需要增加一些支持。因为当使用默认的拷贝构造函数时，执行位拷贝，使得两个不同对象里边的指针指向同一个堆区的空间，这样当某个对象析构的时候，就会释放掉该堆空间，这样就出问题了，可能同一个空间被释放两次。同样赋值操作也存在这样的问题，而且赋值操作的右操作数对象的堆空间可能没有被释放。
一种解决的办法是把拷贝构造函数和赋值操作私有了，使得赋值或使用拷贝构造函数的操作都会被编译器认为不合法。这样就不会出现两个不同的对象指向同一个堆地址空间（boost的scoped_ptr就是这样），也就是说不同的对象不会共享同一个堆地址空间。将那两个函数私有了，会存在很多的限制。
另一种解决方法是，增加一个引用计数，用于统计有多少个对象指向某块相同的堆区域，刚构造一个对象时就在堆上分配一块空间，并让引用计数值为1，当发生拷贝构造，或者该对象作为右值对另一个对象赋值时就让引用计数加1，而不会去分配堆空间。同样的当某个对象不再指向那块堆区域时，引用计数就减1。对象的析构操作和赋值操作都有可能会使得对象的引用计数减为0，所以在这两个函数里边必须判断什么时候引用计数为0，一旦为0，就释放那块堆区域，不为0就不释放。
四、 智能指针
通过对申请和释放内存的封装是避免内存泄漏的基本思路，要使得有通用性、方便还有很多要考虑。现在的很多C++库提供了称为“智能指针”的模板类。使得开发人员可以方便的管理动态内存，而不必担心内存泄漏的问题。
智能指针就是存储指向动态内存/对象的指针和类，其使用和工作机制与C++内置的指针非常相似，而最大的不同是会在适当的时间自动删除指向的内存和对象。此外，一般还提供reset()方法，可以显式释放内存或销毁对象。它们使用operator->和operator*来生成原始指针，这样智能指针看上去就像一个普通指针。但它们要考虑很多因素，例如所有权、线程安全，以及异常安全问题等。
std::auto_ptr的使用。如果发生拷贝，那么被拷贝的源对象对象所指向的堆空间所有权就归目的对象所有，也就说如果一个对象被另一个对象拷贝了，那么那个被拷贝的对象就是“空”的了。不可以用于数组、STL容器。
boost::scoped_ptr的使用。可以通过reset()显式销毁对象。与std::auto_ptr不同，不会发生所有权转移，因为它把拷贝构造函数和赋值重载放到了私有成员里。不可以用于数组、STL容器。
boost::scoped_array的使用。是scoped_ptr的数组形式扩展。
boost::shared_ptr的使用。可拷贝、可赋值。类似于之前的使用了“引用计数”的类。可以通过reset()来解除某个对象对某堆空间区域的指向，这样就使得引用计数减1。可以使用use_count()方法检查当前指向所管理的对象的shared_ptr的个数。
boost::shared_array的使用。支持共享指针的数组形式。会使用delete[]来释放对象。
boost::weak_ptr的使用。跟shared_ptr配合使用，是一种可以在shared_ptr使用之前进行安全检查的类。可以用于多线程的安全访问。weak_ptr的lock()方法返回一个shared_ptr对象，如果该对象存在，则可以使用返回的对象，不然返回的是空指针。
正确的使用智能指针，可以减少开发人员的错误，提高开发效率；如果使用不正确，也将给程序带来灾难。这里的关键是正确地理解每种智能指针的语义，了解其优点和限制。然后结合程序的需求，选择合适的智能指针或者避免使用智能指针。
另外，“侵入式智能指针”跟上边说到的不是同类，可以了解下。
长时间的看同一本书，有些烦躁。
2010-8-30
cs_wuyg@126.com
因为网络问题，没法下载到boost库的安装文件。还好Code::Blocks绿色版里边有.hpp文件和编译好的.lib。。
附上书上的或另外找的学习代码：
1、new_handler的使用
//new_handler的使用.cpp
//2010.8.28
//coder:cs_wuyg@126.com
//参考P151
//Code::Blocks vs
#include <iostream>
using namespace std;
/////////////////////////////////////////////////////////////////
char *gPool = NULL;
void my_new_handler();
/////////////////////////////////////////////////////////////////
int main()
{
set_new_handler(my_new_handler);
gPool = new char[100*1024*1024];
if (gPool != NULL)
{
cout << "Preserve 101MB memeory at " << hex << (void*)gPool << endl;
}
char *p = NULL;
for (int i = 0; i < 20; ++i)
{
p = new char[100*1024*1024];
cout << i+1 << "*100M, p = " << hex << (void*)p << endl;
}
cout << "Done" << endl;
return 0;
}
/////////////////////////////////////////////////////////////////
/*new_handler函数*/
void my_new_handler()
{
if (gPool != NULL)
{
cout << "try to get more memory" << endl;
delete[] gPool;
gPool = NULL;
return;
}
else
{
cout << "I can not help..." << endl;
throw bad_alloc();
}
return ;
}
/*
Preserve 101MB memeory at 00430020
1*100M, p = 06840020
2*100M, p = 0CC50020
3*100M, p = 13060020
4*100M, p = 19470020
5*100M, p = 1F880020
6*100M, p = 25C90020
7*100M, p = 2C0A0020
8*100M, p = 324B0020
9*100M, p = 388C0020
a*100M, p = 3ECD0020
b*100M, p = 450E0020
c*100M, p = 4B4F0020
d*100M, p = 51900020
e*100M, p = 57D10020
f*100M, p = 5E120020
10*100M, p = 64530020
11*100M, p = 6A940020
12*100M, p = 70D50020
try to get more memory
13*100M, p = 00430020
I can not help...
*/
2、placement new的使用
//placement new.cpp
//2010.8.28
//coder：cs_wuug@126.com
//参考P153
//Code::Blocks10.05 VS
#include <iostream>
using namespace std;
int main()
{
char buffer[1024];
char *p = new(buffer) char[20];
cout << "buffer: " << (void*)buffer << endl;
cout <<"p : " << (void*)p << endl;
system("pause");
return 0;
}
/*
buffer: 0012FB68
p : 0012FB68
请按任意键继续. . .
*/
3、自定义类operator new,delete
//自定义类operator new,delete.cpp
//2010.8.28
//coder:cs_wuyg@126.com
//参考P160
//自定义类operator new/delete的使用,基类使用了自定义的new、delete但是派生类不使用自定义的new、delete
//Code::blocks VS
#include <iostream>
using namespace std;
/////////////////////////////////////////////////////////////////////////
class Base
{
public:
int m_Value;
static void* operator new(size_t n);
static void* operator new(size_t n, char* file, int line);
};
void* Base::operator new(size_t n, char* file, int line)
{
cout << "size: " << n << endl
<< "new at " << file << ", " << line << endl;
return ::operator new(n);
}
void* Base::operator new(size_t n)
{
cout << "size: " << n << endl;
return ::operator new(n);
}
class Derived : public Base
{
int m_nDerivedValue;
public:
static void* operator new(size_t n);//重写
static void* operator new(size_t n, char* file, int line);//重写
};
void* Derived::operator new(size_t n, char* file, int line)
{
return ::operator new(n);
}
void* Derived::operator new(size_t n)
{
return ::operator new(n);
}
/////////////////////////////////////////////////////////////////////////
int main()
{
cout << "----------test1----------" << endl;
Base *p1 = new Base;
Base *p2 = new(__FILE__, __LINE__) Base;
cout << "----------test2----------" << endl;
Derived *p3 = new Derived;
Derived *p4 = new(__FILE__, __LINE__) Derived;
char *buffer = new char[10];
system("pause");
return 0;
}
/*
----------test1----------
size: 4
size: 4
new at D:\C++应用程序性能优化学习笔记\第五章动态内存管理\自定义类operator new,delete.cpp, 51
----------test2----------
请按任意键继续. . .
*/
4、“引用计数”类
//引用计数类.cpp
//2010.8.28
//coder:cs_wuyg@126.com
//参考P166
//Code::Block vs
#include <iostream>
using namespace std;
class Base
{
private:
char* m_buf;
size_t m_nsize;
int* m_count;
public:
//constructor
Base(size_t n = 1)
{
m_buf = new char[n];
m_count = new int;
m_nsize = n;
*m_count = 1;
cout << "constructor----count is: " << *m_count << endl;
}
//copy constructor
Base(const Base& bobj)
{
m_nsize = bobj.m_nsize;
m_buf = bobj.m_buf;
m_count = bobj.m_count;
(*m_count)++;
cout << "copyconstructor----count is: " << *m_count << endl;
}
//operator=
Base& operator=(const Base& bobj)
{
if (m_buf == bobj.m_buf)
{
return *this;
}
delete this;
m_buf = bobj.m_buf;
m_nsize = bobj.m_nsize;
m_count = bobj.m_count;
(*m_count)++;
cout << "count is: " << *m_count << endl;
return *this;
}
//destructor
~Base()
{
(*m_count)--;
cout << "count is:" << *m_count << endl;
if (*m_count == 0)
{
cout << "destructor" << endl;
delete[] m_buf;
delete m_count;
}
}
char* getbuf()
{
return m_buf;
}
};
int main()
{
Base obj1(100);
Base obj2(200);
//测试copy constructor
Base obj3 = obj1;
//测试operator=
obj2 = obj1;
cout << "-------Test-------" << endl;
strcpy(obj1.getbuf(), "cs_wuyg");
cout << obj2.getbuf() << endl;
cout << obj3.getbuf() << endl;
system("pause");
return 0;
}
/*
constructor----count is: 1
constructor----count is: 1
copyconstructor----count is: 2
count is:0
destructor
count is: 3
-------Test-------
cs_wuyg
cs_wuyg
请按任意键继续. . .
count is:2
count is:1
count is:0
destructor
*/
5、智能指针std::auto_ptr
//智能指针auto_ptr.cpp
//2010.8.28
//coder:cs_wuyg@126.com
//参考P170
//Code::Blocks 10.05 VS2005/2008
#include <iostream>
#include <string>
#include <memory>//使用auto_ptr
using namespace std;
class Base
{
public:
Base(size_t m_nSize = 10) : m_nSize(m_nSize)
{
cout << "constructor" << endl;
}
~Base()
{
cout << "destructor" << endl;
}
void foo()
{
cout << "-----foo()-----" << endl;
cout << "m_nSize is : " << m_nSize << endl;
}
private:
size_t m_nSize;
};
int main()
{
//定义指向string的智能指针
auto_ptr<string> pString(new string("hello, auto_ptr"));
cout << *pString << endl;
//定义指向Base类对象的智能指针
auto_ptr<Base> pBase(new Base(100));
pBase->foo();
system("pause");
return 0;
}
/*
测试：
hello, auto_ptr
constructor
-----foo()-----
m_nSize is : 100
请按任意键继续. . .
destructor
*/
6、作用域智能指针boost::scoped_ptr
//scoped_ptr.cpp
//2010.8.29
//coder:cs_wuyg@126.com
//参考P173
#include <iostream>
#include <boost\scoped_ptr.hpp>
using namespace std;
class Base
{
public:
Base(size_t m_nSize = 10) : m_nSize(m_nSize)
{
cout << "constructor" << endl;
}
~Base()
{
cout << "destructor" << endl;
}
void foo()
{
cout << "-----foo()-----" << endl;
cout << "m_nSize is : " << m_nSize << endl;
}
private:
size_t m_nSize;
};
int main()
{
boost::scoped_ptr<Base> pBase(new Base);
system("pause");
return 0;
}
/*
constructor
请按任意键继续. . .
destructor
*/
7、boost::scoped_array
//scoped_array.cpp
//coder:cs_wuyg@126.com
//2010.8.29
//参考P173
//测试结果表明，auto_ptr用于数组会有内存泄露
#include <iostream>
#include <memory>
#include <boost/scoped_array.hpp>
using namespace std;
class Base
{
public:
Base(size_t m_nSize = 10) : m_nSize(m_nSize)
{
cout << "constructor" << endl;
}
~Base()
{
cout << "destructor" << endl;
}
void foo()
{
cout << "-----foo()-----" << endl;
cout << "m_nSize is : " << m_nSize << endl;
}
private:
size_t m_nSize;
};
void boostarray()
{
boost::scoped_array<Base> pBase(new Base[2]);
}
void autoarray()
{
auto_ptr<Base> pBase2(new Base[2]);
}
int main()
{
cout << "--------boost array--------" << endl;
boostarray();
cout << "--------boost array--------" << endl;
cout << "--------auto array--------" << endl;
autoarray();
cout << "--------auto array--------" << endl;
system("pause");
return 0;
}
/*
--------boost array--------
constructor
constructor
destructor
destructor
--------boost array--------
--------auto array--------
constructor
constructor
destructor
--------auto array--------
*/
8、boost::shared_ptr
//share_ptr.cpp
//2010.8.29
//coder:cs_wuyg@126.com
//共享智能指针
//参考P174
//Code::Blocks vs2005/2008
#include <iostream>
#include <string>
#include <boost/shared_ptr.hpp>
using namespace std;
class Base
{
public:
Base(size_t m_nSize = 10) : m_nSize(m_nSize)
{
cout << "constructor" << endl;
}
~Base()
{
cout << "destructor" << endl;
}
void foo()
{
cout << "-----foo()-----" << endl;
cout << "m_nSize is : " << m_nSize << endl;
++m_nSize;
}
private:
size_t m_nSize;
};
void shareptr()
{
//试试Base对象使用智能指针
cout << "------------------" << endl;
boost::shared_ptr<Base> pBase1(new Base);
boost::shared_ptr<Base> pBase2(pBase1);
pBase1->foo();
pBase2->foo();
cout << "------------------" << endl;
//测试使用use_count、reset
cout << "use count is : " << pBase2.use_count() << endl;
pBase1.reset();
cout << "use count is : " << pBase2.use_count() << endl;
pBase2.reset();
//试试string对象使用智能指针
cout << "------------------" << endl;
boost::shared_ptr<string> pstr1(new string("cswuyg"));
boost::shared_ptr<string> pstr2(pstr1);
cout << pstr1 << endl;
cout << pstr2 << endl;
}
int main()
{
shareptr();
system("pause");
return 0;
}
/*
------------------
constructor
-----foo()-----
m_nSize is : 10
-----foo()-----
m_nSize is : 11
------------------
use count is : 2
use count is : 1
destructor
------------------
003844A0
003844A0
请按任意键继续. . .
*/
9、boost::shared_array
//共享数组指针.cpp
//2010.8.29
//coder:cs_wuyg@126.com
//练习共享数组智能指针。boost::shared_array
//Code::Blocks vs2005/2008
#include <iostream>
#include <string>
#include <boost/shared_array.hpp>
using namespace std;
class Base
{
public:
Base(size_t m_nSize = 10) : m_nSize(m_nSize)
{
cout << "constructor" << endl;
}
~Base()
{
cout << "destructor" << endl;
}
void foo()
{
cout << "-----foo()-----" << endl;
cout << "m_nSize is : " << m_nSize << endl;
}
private:
size_t m_nSize;
};
int main()
{
boost::shared_array<Base> pstr1(new Base[2]);
boost::shared_array<Base> pstr2(pstr1);
cout << &pstr2[0] << endl;
cout << &pstr2[1] << endl;
cout << "----------------" << endl;
cout << &pstr1[0] << endl;
cout << &pstr1[1] << endl;
system("pause");
return 0;
}
/*
constructor
constructor
00382E74
00382E78
----------------
00382E74
00382E78
请按任意键继续. . .
destructor
destructor
*/
10、boost::weak_ptr
//weak_ptr.cpp //coder:cs_wuyg@126.com //2010.8.29 //参考P179 //Code::Blocks vs2005/2008 #include <iostream> #include <memory> #include <boost/weak_ptr.hpp> #include <boost/shared_ptr.hpp> using namespace std; class Base { public: Base(size_t m_nSize = 10) : m_nSize(m_nSize) { cout << "constructor" << endl; } ~Base() { cout << "destructor" << endl; } void foo() { cout << "-----foo()-----" << endl; cout << "m_nSize is : " << m_nSize << endl; ++m_nSize; } private: size_t m_nSize; }; void testptr() { boost::shared_ptr<Base> pBase1(new Base); boost::weak_ptr<Base> pBase2(pBase1); // pBase1.reset();//加上这句作测试，weak_ptr的作用，使用weak_ptr的lock可以保证shared_ptr对象存在时才执行。 boost::shard_ptr<Base> pBase2_1(pBase2->lock());// 提升为shard_ptr，线程安全.保证下面执行时的执行引用计数至少为1. if (pBase2_1) { pBase2_1->foo(); } else { cout << "Base obj is delete!!" << endl; } try { boost::shared_ptr<Base> pBase3(pBase2); pBase3->foo(); }catch(boost::bad_weak_ptr) { cout << "Base obj is delete, can not construct shared_ptr!!" << endl; } } int main() { testptr(); system("pause"); return 0; } /* constructor -----foo()----- m_nSize is : 10 -----foo()----- m_nSize is : 11 destructor 请按任意键继续. . . */
