使用 shared_ptr

shared_ptr是一個模板類,它保存了一個指向動態分配的對象的指針,當指向這個對象的最後一個shared_ptr被銷燬的時候,這個對象也被銷燬了。

有三種使用 shared_ptr的方法:

1)使用 std::shared_ptr

要用 std::shared_ptr的方式使用。

實例代碼:

#include <iostream>
#include <memory>
class A
{
public:
	A()
	{
		std::cout <<"A constructor" << std::endl;
		a = new int(3);
	}
	~A()
	{
		std::cout <<"A destructor" << std::endl;
		delete a;
		a = NULL;
	}
	void Print(void)
	{
		std::cout << "a = " <<*a << std::endl;
	}
private:
	int *a;
};

void foo(std::shared_ptr<A> pA)
{
	std::cout <<"user count : ##" << pA.use_count() << std::endl;
	std::shared_ptr <A> pB = pA;
	std::cout <<"user count : ###" << pA.use_count() << std::endl;
	pB.get()->Print();
}

int main(void)
{
	std::shared_ptr<A> p1 (new A);
	std::cout << "use count #" << p1.use_count() << std::endl;
	foo(p1);
	std::cout << "use count ####" << p1.use_count() << std::endl;
	return 0;
}

編譯的時候,要加上 -std=c++11選項,因爲 shared_ptr是 c++11標準的一部分。

2)使用  tr1:shared_ptr

要用std:tr1::shared_ptr的方式使用

實例代碼:

#include <iostream>
#include <tr1/memory>

class A
{
public:
	A()
	{
		std::cout <<"A constructor" << std::endl;
		a = new int(3);
	}
	~A()
	{
		std::cout <<"A destructor" << std::endl;
		delete a;
		a = NULL;
	}
	void Print(void)
	{
		std::cout << "a = " <<*a << std::endl;
	}
private:
	int *a;
};

void foo(std::tr1::shared_ptr<A> pA)
{
	std::cout <<"user count : ##" << pA.use_count() << std::endl;
	std::tr1::shared_ptr <A> pB = pA;
	std::cout <<"user count : ###" << pA.use_count() << std::endl;
	pB.get()->Print();
}

int main(void)
{
	std::tr1::shared_ptr<A> p1 (new A);
	std::cout << "use count #" << p1.use_count() << std::endl;
	foo(p1);
	std::cout << "use count ####" << p1.use_count() << std::endl;
	return 0;
}

這種情況下,直接用g++編譯就行了。

3)使用 boost庫。

要先確保已經安裝了 boost庫。在 ubuntu上,可以用下面的方法檢查:

$ dpkg --get-selections  | grep boost
libboost-date-time1.54.0:i386			install
libboost-dev					install
libboost-iostreams1.54.0:i386			install
libboost-system1.54.0:i386			install
libboost1.54-dev				install

要用 boost::shared_ptr的方式使用。

實例代碼:

#include <iostream>
//#include <memory>
#include <boost/tr1/tr1/memory>

class A
{
public:
	A()
	{
		std::cout <<"A constructor" << std::endl;
		a = new int(3);
	}
	~A()
	{
		std::cout <<"A destructor" << std::endl;
		delete a;
		a = NULL;
	}
	void Print(void)
	{
		std::cout << "a = " <<*a << std::endl;
	}
private:
	int *a;
};

void foo(boost::shared_ptr<A> pA)
{
	std::cout <<"user count : ##" << pA.use_count() << std::endl;
	boost::shared_ptr <A> pB = pA;
	std::cout <<"user count : ###" << pA.use_count() << std::endl;
	pB.get()->Print();
}

int main(void)
{
	boost::shared_ptr<A> p1 (new A);
	std::cout << "use count #" << p1.use_count() << std::endl;
	foo(p1);
	std::cout << "use count ####" << p1.use_count() << std::endl;
	return 0;
}

也可以直接用 g++編譯。

References:

1) http://stackoverflow.com/questions/2918202/where-is-shared-ptr

2)http://www.boost.org/doc/libs/1_58_0/libs/smart_ptr/shared_ptr.htm

时间: 2024-11-04 13:07:39

使用 shared_ptr的相关文章

实现类似shared_ptr的引用计数

13.27 定义使用引用计数版本的HasPtr #include<iostream> #include<string> #include<new> using namespace std; class HasPtr { public: HasPtr(const string &s=string()):ps(new string(s)),i(0),use(new size_t(1)) {cout<<"constructer"<

智能指针tr1::shared_ptr、boost::shared_ptr使用

对于tr1::shared_ptr在安装vs同时会自带安装,但是版本较低的不存在.而boost作为tr1的实现品,包含 "Algorithms Broken Compiler Workarounds Concurrent Programming Containers Correctness and Testing Data Structures Domain Specific Function Objects and Higher-order Programming Generic Progra

C++ shared_ptr

晕晕乎乎,其他的再补充 1.shared_ptr 主要是为了方便管理内存而存在的,C++程序中不会再出现new 和 delete,内存的分配和析构全部由shared_ptr进行管理 2.当程序中对某个对象进行复制或者引用的时候,shared_ptr会有一个引用计数这个东西,每当使用一次就+1,用完之后-1,直到减为0的时候再将申请的内存(资源)释放掉

C++智能指针剖析(下)boost::shared_ptr&amp;其他

1. boost::shared_ptr 前面我已经讲解了两个比较简单的智能指针,它们都有各自的优缺点.由于 boost::scoped_ptr 独享所有权,当我们真真需要复制智能指针时,需求便满足不了了,如此我们再引入一个智能指针,专门用于处理复制,参数传递的情况,这便是如下的boost::shared_ptr. boost::shared_ptr 属于 boost 库,定义在 namespace boost 中,包含头文件#include<boost/smart_ptr.hpp> 便可以使

shared_ptr 和 unique_ptr

c++11标准废除乐auto_ptr, C++ 标准库智能指针 使用这些智能指针作为将指针封装为纯旧 C++ 对象 (POCO) 的首选项. unique_ptr 只允许基础指针的一个所有者. 除非你确信需要 shared_ptr,否则请将该指针用作 POCO 的默认选项. 可以移到新所有者,但不会复制或共享. 替换已弃用的auto_ptr. 与 boost::scoped_ptr 比较. unique_ptr 小巧高效:大小等同于一个指针且支持 rvalue 引用,从而可实现快速插入和对 ST

Boost库中shared_ptr(上)

1.共享性智能指针(shared_ptr) 引用计数型指针 shared_ptr是一个最像指针的"智能指针",是boost.smart_ptr库中最有价值,最重要,也是最有用的.  shared_ptr实现的是引用技术型的智能指针,可以被拷贝和赋值,在任意地方共享它,当没有代码使用(此时引用         计数为0)它才删除被动态分配的对象.shared_ptr也可以被安全的放到标准容器中: 2.怎么使用shared_ptr 举一个操作的例子: #include<iostrea

智能指针的模拟实现 auto_ptr scoped_ptr shared_ptr

RAII(Resource Acquisition Is Initialization) 资源分配即初始化,定义一个类来封装资源的分配和释放,在构造函数完成资源的分配和初始化,在析构函数完成资源的清理,可以保证资源的正确初始化和释放. 智能指针:用自动化或者说智能的指针来实现对动态内存的释放.它是一个类,有类似指针的功能. 常见的智能指针:auto_ptr/scoped_ptr/scoped_array/shared_ptr/shared_array,由于scoped_array和scoped_

智能指针的模拟实现shared_ptr 循环引用 定置删除器

auto_ptr与scoped_ptr的实现见本人的上篇博客. 三.shared_ptr shared_ptr的实现原理是通过引用计数来实现,只有当引用计数为1时才释放空间,否则只需将引用计数减1.拷贝和赋值将引用计数加1,具体代码如下: template <typename T> class SharedPtr { public: SharedPtr(); SharedPtr(T* ptr); SharedPtr(const SharedPtr<T>& ap); ~Sha

智能指针 std::auto_ptr 和 shared_ptr

需要注意: auto_ptr 类可以用于管理由 new 分配的单个对象,但是无法管理动态分配的数组(我们通常不会使用数组,而是使用 vector 代替数组).auto_ptr 在拷贝和赋值的时候有不寻常的行为,因此 auto_ptrs 不能被保存在 stl 的容器中.当 auto_ptr 离开了自己的作用域或者被销毁,由 auto_ptr 管理的对象也会被销毁. 使用std::auto_ptr需要的头文件: #include <memory> // 示例 1(b): 安全代码, 使用了auto

智能指针——shared_ptr

boost::scoped_ptr虽然简单易用,但它不能共享所有权的特性却大大限制了其使用范围,而boost::shared_ptr可以解决这一局限.顾名思义,boost::shared_ptr是可以共享所有权的智能指针 boost::shared_ptr的管理机制其实并不复杂,就是对所管理的对象进行了引用计数,当新增一个boost::shared_ptr对该对象进行管理时,就将该对象的引用计数加一:减少一个boost::shared_ptr对该对象进行管理时,就将该对象的引用计数减一,如果该对