C++学习 std::tr1::shared_ptr使用的一点体会tr1库介绍

Technical Report 1 是一份规范，描述加入C++标准程序的诸多新技能，以新的class templates 和 function templates 形式体现，针对的题目有哈希表，基于引用计数的智能指针，正则表达式等。大多数TR1机能是以Boost的工作为基础的。TR组件位于std::tr1命名空间中。

 

tr1::shared_ptr 的使用和boost::shared_ptr 类似，都是基于引用计数值的智能指针。#include <memory> 以使用shared_ptr。

1. 在可能会引起循环引用的地方，使用weak_ptr。

[cpp] view plain copy print ?

1. #include <iostream>  
2. #include <memory>  
3.   
4. class A;  
5. class B;  
6. typedef std::tr1::shared_ptr<A> APtr;  
7. typedef std::tr1::shared_ptr<B> BPtr;  
8.   
9. class A  
10. {  
11. public:  
12.     BPtr b;  
13.     ~A()  
14.     {  
15.         std::cout << "A released." << std::endl;  
16.     }  
17. };  
18.   
19. class B  
20. {  
21. public:  
22.     APtr a;  
23.     ~B()  
24.     {  
25.         std::cout << "B released." << std::endl;  
26.     }  
27. };  
28.   
29. int _tmain(int argc, _TCHAR* argv[])  
30. {  
31.     APtr objA(new A());  
32.     BPtr objB(new B());  
33.   
34.     objA->b = objB; //1  
35.     objB->a = objA; //2  
36.     return 0;  
37. }  

<span style="font-size:12px;">#include <iostream>
#include <memory>

class A;
class B;
typedef std::tr1::shared_ptr<A> APtr;
typedef std::tr1::shared_ptr<B> BPtr;

class A
{
public:
	BPtr b;
	~A()
	{
		std::cout << "A released." << std::endl;
	}
};

class B
{
public:
	APtr a;
	~B()
	{
		std::cout << "B released." << std::endl;
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	APtr objA(new A());
	BPtr objB(new B());

	objA->b = objB; //1
	objB->a = objA; //2
	return 0;
}</span>

执行完什么也没有输出，说明 A  和 B 都没有执行析构函数，资源泄漏了。指针objA 的生命周期结束时，对其的引用计数为1，即objB手中的引用，所以对象objA不会释放。objB 同理。注释为 1 和 2 的两句，任意去掉一句，就打破了循环引用，objA 和 objB 都能正常释放。

如果两个对象之间需要互相引用，使用std::tr1::weak_ptr，它不会增加引用计数，当需要使用这个对象的时候，可以从weak_ptr中临时生出一个shared_ptr 来（引用计数+1），这个临时的shared_ptr 生命结束后，会把引用计数减小 1，避免出现互相死锁的情况。

[cpp] view plain copy print ?

1. #include <iostream>  
2. #include <memory>  
3.   
4. class A;  
5. class B;  
6. typedef std::tr1::shared_ptr<A> APtr;  
7. typedef std::tr1::shared_ptr<B> BPtr;  
8. typedef std::tr1::weak_ptr<A> AWeakPtr;  
9. typedef std::tr1::weak_ptr<B> BWeakPtr;  
10.   
11. class A  
12. {  
13. public:  
14.     BWeakPtr b;  
15.     ~A()  
16.     {  
17.         std::cout << "A released." << std::endl;  
18.     }  
19. };  
20.   
21. class B  
22. {  
23. public:  
24.     AWeakPtr a;  
25.     ~B()  
26.     {  
27.         std::cout << "B released." << std::endl;  
28.     }  
29.   
30.     void Print()  
31.     {  
32.         std::cout << "I'm in B!" << std::endl;  
33.     }  
34. };  
35.   
36. class C : public std::tr1::enable_shared_from_this<C>  
37. {  
38. public:  
39.     std::tr1::shared_ptr<C> getSharedPtr()  
40.     {  
41.         return shared_from_this();  
42.     }  
43. };  
44.   
45. int _tmain(int argc, _TCHAR* argv[])  
46. {  
47.     APtr objA(new A());  
48.     BPtr objB(new B());  
49.   
50.     objA->b = objB;  
51.     objB->a = objA;  
52.   
53.     BPtr objB2(objA->b.lock()); //获得shared_ptr  
54.     objB2->Print();  
55.   
56.     return 0;  
57. }  

<span style="font-size:12px;">#include <iostream>
#include <memory>

class A;
class B;
typedef std::tr1::shared_ptr<A> APtr;
typedef std::tr1::shared_ptr<B> BPtr;
typedef std::tr1::weak_ptr<A> AWeakPtr;
typedef std::tr1::weak_ptr<B> BWeakPtr;

class A
{
public:
	BWeakPtr b;
	~A()
	{
		std::cout << "A released." << std::endl;
	}
};

class B
{
public:
	AWeakPtr a;
	~B()
	{
		std::cout << "B released." << std::endl;
	}

	void Print()
	{
		std::cout << "I'm in B!" << std::endl;
	}
};

class C : public std::tr1::enable_shared_from_this<C>
{
public:
	std::tr1::shared_ptr<C> getSharedPtr()
	{
		return shared_from_this();
	}
};

int _tmain(int argc, _TCHAR* argv[])
{
	APtr objA(new A());
	BPtr objB(new B());

	objA->b = objB;
	objB->a = objA;

	BPtr objB2(objA->b.lock()); //获得shared_ptr
	objB2->Print();

	return 0;
}</span>

 

在 A 和 B 内部都使用weak_ptr，weak_ptr 的 lock()，相当于 shared_ptr 的 get()。对上例来说，其实只需要一个地方使用weak_ptr就可以了。

2. 从对象的原始指针，生成需要的shared_ptr。

使用std::tr1::enable_shared_from_this 作为基类。这样可以从 this 生成具有统一计数的 shared_ptr了。

[cpp] view plain copy print ?

1. class C : public std::tr1::enable_shared_from_this<C>  
2. {  
3. public:  
4.     std::tr1::shared_ptr<C> getSharedPtr()  
5.     {  
6.         return shared_from_this();  
7.     }  
8. };  

<span style="font-size:12px;">class C : public std::tr1::enable_shared_from_this<C>
{
public:
	std::tr1::shared_ptr<C> getSharedPtr()
	{
		return shared_from_this();
	}
};</span>

shared_from_this() 不能在构造函数中使用，因为在 enable_shared_from_this 这个基类内部，是通过一个对自己的 weak_ptr 的引用来返回 this 的shared_ptr 的，而在对象的构造函数中，第一个 shared_ptr 尚未获得指针，所以 weak_ptr 是空的，shared_from_this() 返回会失败。

 

sp_counted_base_w32.hpp

[cpp] view plain copy print ?

1. void add_ref_copy()  
2. {  
3.     BOOST_INTERLOCKED_INCREMENT( &use_count_ );  
4. }  

<span style="font-size:12px;">    void add_ref_copy()
    {
        BOOST_INTERLOCKED_INCREMENT( &use_count_ );
    }
</span>

[cpp] view plain copy print ?

1. void release() // nothrow  
2. {  
3.     if( BOOST_INTERLOCKED_DECREMENT( &use_count_ ) == 0 )  
4.     {  
5.         dispose();  
6.         weak_release();  
7.     }  
8. }