你说你会C++? —— 智能指针

智能指针的设计初衷是：

     C++中没有提供自己主动回收内存的机制，每次new对象之后都须要手动delete。稍不注意就memory leak。

智能指针能够解决上面遇到的问题。

C++中常见的智能指针包含(共七种)：

     std::auto_ptr

     boost::scoped_ptr

     boost::shared_ptr

     boost::intrusive_ptr

     boost::scoped_array

     boost::shared_array

     boost::weak_ptr

    事实上，智能指针并非指针，它不过一个栈对象而已。

在栈对象的生命周期结束时，智能指针调用析构函数释放其管理的堆内存。

全部的智能指针都重载了'operator->'操作符，用来返回其管理对象的引用。从而能够

运行所管理对象的一些操作。

两个方法：

     - get()

          訪问智能指针包括的裸指针引用

     - reset()

          若传递參数为空或NULL 则智能指针会释放当前管理的内存。

          若传递參数为一个对象 则智能指针会释放当前管理的内存，管理新传入的对象。

假定有以下这个ManagedObj类。

class ManagedObj
{
public:
    ManagedObj(int val = 0):m_val(val)
    {
        cout<<"Obj : "<<m_val<<endl;
    }
 
    ~ManagedObj()
    {
        cout<<"~Obj : "<<m_val<<endl;
    }
 
    void testFun()
    {
        cout<<"testFun : "<<m_info<<endl;
    }
 
public:
    string m_info;
    int m_val;
};

-> std::auto_ptr

---

属于STL

在namespace std中

加入头文件 #include <memory>就可以使用。

auto_ptr一般用于管理单个堆内存对象。

看以下这个样例：

// std::auto_ptr
void testAutoPtr1()
{
    auto_ptr<ManagedObj> atPtr(new ManagedObj(1, " initialize"));
 
    if (atPtr.get())    // 推断智能指针是否为空
    {
        atPtr->testFun();
 
        atPtr.get()->m_info += " 1st append";    // get() 返回裸指针的引用
        atPtr->testFun();
 
        (*atPtr).m_info += " 2nd append";        // operator* 返回智能指针管理的对象
        (*atPtr).testFun();
    }
}

执行结果为：

OK 好像没什么问题。

我们接着測试：

void testAutoPtr2()
{
    auto_ptr<ManagedObj> atPtr(new ManagedObj(1, " initialize"));
 
    if (atPtr.get())    // 推断智能指针是否为空
    {
        auto_ptr<ManagedObj> atPtr2;
 
        atPtr2 = atPtr;               // 原因在这行代码
        atPtr2->testFun();
        atPtr->testFun();          // 崩溃在这行代码
    }
}

执行结果为：

调试发现 最后一行代码出bug了。

为什么呢？

事实上是atPtr2剥夺了atPtr的内存管理全部权，导致atPtr悬空。

继续測试。

void testAutoPtr3()
{
    auto_ptr<ManagedObj> atPtr(new ManagedObj(1, " initialize"));
 
    if (atPtr.get())    // 推断智能指针是否为空
    {
        atPtr.release();
    }
}

执行结果为：

好像又出bug了。

我们并没有看到析构函数被调用的迹象，内存泄漏了。。

(逗我呢 怎么这么多bug?

)

别着急 第三个測试函数正确的写法应该是这种。

void testAutoPtr3()
{
    auto_ptr<ManagedObj> atPtr(new ManagedObj(1, " initialize"));
 
    if (atPtr.get())    // 推断智能指针是否为空
    {
        //ManagedObj* temp = atPtr.release();
        //delete temp;
 
        // 或者
        atPtr.reset();
    }
}

这才是我们想要看到的结果。

所以我们也发现。auto_ptr的release()函数仅仅是让出内存的管理权，并没有真正的释放内存。

总结：

     auto_ptr一般用于管理单个堆内存对象。

可是须要注意：

     a. 切记使用 "operator="。万一真用了，就不要再使用旧的对象了。

     b. release()方法不会释放内存 只不过让出全部权。

上面的auto_ptr使用起来确实不是非常方便，并且我们还有注意避开它的使用缺陷。

因此就出现了boost中的一些智能指针，以下一一介绍。

-> boost::scoped_ptr

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

关于boost库的安装教程 可參考：

http://blog.csdn.net/misskissc/article/details/9793645

http://www.cnblogs.com/xuqiang/archive/2011/05/08/2040420.html

与auto_ptr类似。scoped_ptr也可管理单个堆内存的对象，

可是它独享全部权，因此也就避免了auto_ptr的缺陷。

OK。上代码測试。

// boost::scoped_ptr
void testScopedPtr()
{
	boost::scoped_ptr<ManagedObj> scPtr(new ManagedObj(1, " initialize"));
 
	if (scPtr.get())
	{
		scPtr->testFun();
 
		scPtr.get()->m_info += " 1st append";	// get() 返回裸指针的引用
		scPtr->testFun();
 
		(*scPtr).m_info += " 2nd append";		// operator* 返回智能指针管理的对象
		(*scPtr).testFun();
 
		//scPtr.release();				// error scoped_ptr 没有成员release
 
		//boost::scoped_ptr<ManagedObj> scPtr2;
		//scPtr2 = scPtr;					// error scoped_ptr<T>::operator=(const scoped_ptr<ManagedObj> &)不可訪问
	}
}

执行结果为：

注意凝视部分的代码。

scoped_ptr没有release()函数  屏蔽了operator=操作，

因此不会出现auto_ptr中出现的内存泄漏和崩溃问题。

但这也带来了还有一个新问题。我们无法复制智能指针。

因此出现了接下来的shared_ptr。

-> boost::shared_ptr

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

因为scoped_ptr不同意赋值 拷贝 独享内存的全部权。

这里的shared_ptr是专门解决智能指针的内存全部权共享这个问题的。

其内部使用了引用计数。

来，測试吧。

// boost::shared_ptr
void testSharedPtr(boost::shared_ptr<ManagedObj> ptr)
{
    ptr->testFun();
    cout<<"shared_ptr use_count: "<<ptr.use_count()<<endl;
}
 
void testSharedPtr1()
{
    boost::shared_ptr<ManagedObj> shPtr(new ManagedObj(1, " initialize"));
 
    if (shPtr.get())
    {
        shPtr->testFun();
 
        shPtr.get()->m_info += " 1st append";    // get() 返回裸指针的引用
        shPtr->testFun();
 
        (*shPtr).m_info += " 2nd append";        // operator* 返回智能指针管理的对象
        (*shPtr).testFun();
    }
 
    cout<<"shared_ptr1 use_count: "<<shPtr.use_count()<<endl;
    testSharedPtr(shPtr);
    cout<<"shared_ptr1 use_count: "<<shPtr.use_count()<<endl;
     //shPtr.release(); // error shared_ptr 没有成员release
}

执行结果为：

能够看到。调用testSharedPtr()函数运行了一次复制操作，智能指针内部的引用计数+1。

在该函数调用结束后，引用计数自己主动-1。

上面介绍的几种智能指针都针对单个对象的内存管理。

事实上智能指针也可管理数组，接下来介绍boost::scoped_array和boost::shared_array。

-> boost::scoped_array

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

boost::scoped_array用于管理动态数组。也是独享全部权的。

上代码：

// boost::scoped_array
void testScopedArray()
{
    boost::scoped_array<ManagedObj> scArr(new ManagedObj[2]);        // 动态数组初始化
 
    if (scArr.get())
    {
        scArr[0].testFun();
 
        scArr.get()[0].m_info += " [0] 1st append";
        scArr[0].testFun();
 
        //(*scArr)[0].m_info += " 2st append";    // error scoped_array没有重载operator*
        //(*scArr)[0].testFun();
 
        //scArr[0].release();                        // error scoped_array 没有成员release
 
        boost::scoped_array<ManagedObj> scArr2;
        //scArr2 = scArr;                // error operator=不可訪问 屏蔽了operator= 禁止拷贝
    }
}

执行结果为：

boost::scoped_array的使用和boost::scoped_ptr大致几乎相同。

都禁止拷贝 独享全部权。

注意：

     boost::scoped_array没有重载operator*操作符

-> boost::shared_array

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

内部使用了引用计数，解决參数传递和拷贝赋值时的问题。

以下给出代码測试：

// boost::shared_array
void testSharedArray(boost::shared_array<ManagedObj> pArr)
{
    cout<<"shared_arr use_count: "<<pArr.use_count()<<endl;
    boost::shared_array<ManagedObj> pTempArr;
    pTempArr = pArr;
    cout<<"shared_arr use_count: "<<pArr.use_count()<<endl;
}
 
void testSharedArray1()
{
    boost::shared_array<ManagedObj> shArr(new ManagedObj[2]);
 
    if (shArr.get())
    {
        shArr[0].testFun();
 
        shArr.get()[0].m_info += " [0] 1st append";
        shArr[0].testFun();
        shArr[1].testFun();
 
        shArr.get()[0].m_info += " [1] 1st append";
        shArr[1].testFun();
        //(*shArr)[0].m_info += " [0] 2nd append";    // error 没有重载operator*操作符
    }
 
    cout<<"shared_arr1 use_count: "<<shArr.use_count()<<endl;
    testSharedArray(shArr);
    cout<<"shared_arr1 use_count: "<<shArr.use_count()<<endl;
}

执行结果为：

-> boost::weak_ptr

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

若我们只关心是否能使用对象。而不关心内部的引用计数。

boost::weak_ptr 是 boost::shared_ptr 的观察者(Observer)对象，

意味着boost::weak_ptr仅仅对boost::shared_ptr引用。可是并不更新

其引用计数。被观察的shared_ptr失效后，weak_ptr对应也失效。

上測试代码：

// boost::weak_ptr
void testWeakPtr()
{
    boost::weak_ptr<ManagedObj> wPtr;
    boost::shared_ptr<ManagedObj> shPtr(new ManagedObj(1, "initialize"));
 
    cout << "testWeakPtr boost::shared_ptr UseCount: " << shPtr.use_count() << endl;
    wPtr = shPtr;
    cout << "testWeakPtr boost::shared_ptr UseCount: " << shPtr.use_count() << endl;
}

执行结果为：

我们发现赋值操作并没有更改引用计数。

boost::weak_ptr很多其它用于以下这样的场合：

     在基类中定义一个weak_ptr，用于观察其子类中的shared_ptr。这样基类仅仅要看自己的weak_ptr

是否为空就知道子类有没对自己赋值，而不影响子类中shared_ptr的引用计数。从而减少复杂度。更好管理对象。

-> boost::intrusive_ptr

---

属于boost库

在namespace boost中

加入头文件 #include<boost/smart_ptr.hpp> 就可以使用。

intrusive_ptr是一种插入式智能指针，其内部没有引用计数，

须要自己增加引用计数，否则会编译错误。

OK 到这儿为止，七种智能指针基本上都大致介绍完了。

參考：

http://blog.csdn.net/xt_xiaotian/article/details/5714477

完整的代码在这里。

#include <iostream>
#include <memory>
#include <string>
#include <boost/smart_ptr.hpp>			// add header file
 
// namespace
using namespace std;
using namespace boost;
 
// heap obj class
class ManagedObj
{
public:
	ManagedObj(int val = 0, string info = "")
		:m_val(val), m_info(info)
	{
		cout<<"Obj : "<<m_val<<m_info<<endl;
	}
 
	~ManagedObj()
	{
		cout<<"~Obj : "<<m_val<<m_info<<endl;
	}
 
	void testFun()
	{
		cout<<"testFun : "<<m_info<<endl;
	}
 
public:
	string m_info;
	int m_val;
};
 
// std::auto_ptr
void testAutoPtr1()
{
	auto_ptr<ManagedObj> atPtr(new ManagedObj(1, " initialize"));
 
	if (atPtr.get())	// 推断智能指针是否为空
	{
		atPtr->testFun();
 
		atPtr.get()->m_info += " 1st append";	// get() 返回裸指针的引用
		atPtr->testFun();
 
		(*atPtr).m_info += " 2nd append";		// operator* 返回智能指针管理的对象
		(*atPtr).testFun();
	}
}
 
void testAutoPtr2()
{
	auto_ptr<ManagedObj> atPtr(new ManagedObj(1, " initialize"));
 
	if (atPtr.get())	// 推断智能指针是否为空
	{
		auto_ptr<ManagedObj> atPtr2;
 
		atPtr2 = atPtr;
		atPtr2->testFun();
		atPtr->testFun();
	}
}
 
void testAutoPtr3()
{
	auto_ptr<ManagedObj> atPtr(new ManagedObj(1, " initialize"));
 
	if (atPtr.get())	// 推断智能指针是否为空
	{
		//ManagedObj* temp = atPtr.release();
		//delete temp;
 
		// 或者
		atPtr.reset();
	}
}
 
// boost::scoped_ptr
void testScopedPtr()
{
	boost::scoped_ptr<ManagedObj> scPtr(new ManagedObj(1, " initialize"));
 
	if (scPtr.get())
	{
		scPtr->testFun();
 
		scPtr.get()->m_info += " 1st append";	// get() 返回裸指针的引用
		scPtr->testFun();
 
		(*scPtr).m_info += " 2nd append";		// operator* 返回智能指针管理的对象
		(*scPtr).testFun();
 
		//scPtr.release();				// error scoped_ptr 没有成员release
 
		//boost::scoped_ptr<ManagedObj> scPtr2;
		//scPtr2 = scPtr;					// error scoped_ptr<T>::operator=(const scoped_ptr<ManagedObj> &)不可訪问
	}
}
 
// boost::shared_ptr
void testSharedPtr(boost::shared_ptr<ManagedObj> ptr)
{
	ptr->testFun();
	cout<<"shared_ptr use_count: "<<ptr.use_count()<<endl;
}
 
void testSharedPtr1()
{
	boost::shared_ptr<ManagedObj> shPtr(new ManagedObj(1, " initialize"));
 
	if (shPtr.get())
	{
		shPtr->testFun();
 
		shPtr.get()->m_info += " 1st append";	// get() 返回裸指针的引用
		shPtr->testFun();
 
		(*shPtr).m_info += " 2nd append";		// operator* 返回智能指针管理的对象
		(*shPtr).testFun();
	}
 
	cout<<"shared_ptr1 use_count: "<<shPtr.use_count()<<endl;
	testSharedPtr(shPtr);
	cout<<"shared_ptr1 use_count: "<<shPtr.use_count()<<endl;
 
	//shPtr.release();	// error shared_ptr 没有成员release
}
 
// boost::scoped_array
void testScopedArray()
{
	boost::scoped_array<ManagedObj> scArr(new ManagedObj[2]);		// 动态数组初始化
 
	if (scArr.get())
	{
		scArr[0].testFun();
 
		scArr.get()[0].m_info += " [0] 1st append";
		scArr[0].testFun();
 
		//(*scArr)[0].m_info += " 2st append";	// error scoped_array没有重载operator*
		//(*scArr)[0].testFun();
 
		//scArr[0].release();						// error scoped_array 没有成员release
 
		boost::scoped_array<ManagedObj> scArr2;
		//scArr2 = scArr;				// error operator=不可訪问 屏蔽了operator= 禁止拷贝
	}
}
 
// boost::shared_array
void testSharedArray(boost::shared_array<ManagedObj> pArr)
{
	cout<<"shared_arr use_count: "<<pArr.use_count()<<endl;
 
	boost::shared_array<ManagedObj> pTempArr;
	pTempArr = pArr;
	cout<<"shared_arr use_count: "<<pArr.use_count()<<endl;
}
 
void testSharedArray1()
{
	boost::shared_array<ManagedObj> shArr(new ManagedObj[2]);
 
	if (shArr.get())
	{
		shArr[0].testFun();
 
		shArr.get()[0].m_info += " [0] 1st append";
		shArr[0].testFun();
		shArr[1].testFun();
 
		shArr.get()[1].m_info += " [1] 1st append";
		shArr[1].testFun();
		//(*shArr)[0].m_info += " [0] 2nd append";	// error 没有重载operator*操作符
	}
 
	cout<<"shared_arr1 use_count: "<<shArr.use_count()<<endl;
	testSharedArray(shArr);
	cout<<"shared_arr1 use_count: "<<shArr.use_count()<<endl;
}
 
// boost::weak_ptr
void testWeakPtr()
{
	boost::weak_ptr<ManagedObj> wPtr;
	boost::shared_ptr<ManagedObj> shPtr(new ManagedObj(1, "initialize"));
 
	cout << "testWeakPtr boost::shared_ptr UseCount: " << shPtr.use_count() << endl;
	wPtr = shPtr;
	cout << "testWeakPtr boost::shared_ptr UseCount: " << shPtr.use_count() << endl;
}
 
// boost::intrusive_ptr
void testIntrusivePtr()
{
	//boost::intrusive_ptr<ManagedObj> intPtr(new ManagedObj[1], false);	// error 要自己加入引用计数
}
 
// main function
int main(void)
{
	// -----std::auto_ptr-----
	//testAutoPtr();
	//testAutoPtr2();
	//testAutoPtr3();
 
	// -----boost::scoped_ptr-----
	//testScopedPtr();
 
	// -----boost::shared_ptr-----
	//testSharedPtr1();
 
	// -----boost::scoped_array-----
	//testScopedArray();
 
	// -----boost::shared_array-----
	//testSharedArray1();
 
	// -----boost::weak_ptr-----
	testWeakPtr();
 
	return 0;
}