Boost库学习随记三 smart_ptr库、soped_ptr、scoped_array、shared_ptr、shared_array、weak_ptr等等

#include <iostream>
#include <string>
#include <vector>
#include <cstdlib>
#include <boost/smart_ptr.hpp>
//#include <boost/pool/object_pool.hpp>


using namespace std;
using namespace boost;

//smart_ptr库
//soped_ptr智能指针示例：
bool scoped_ptr_fun()
{
	{
		//soped_ptr简单示例一
		scoped_ptr<string> sp(new string("text"));
		cout << *sp << endl;    //取字符串的内容
		cout << sp->size() << endl;  //取字符串的长度
		//sp++; 错误 scoped_ptr求定义递增操作符  
		//scoped_ptr<string> sp2 =sp;   错误scoped_ptr不能拷贝构造
	}


	{
		//soped_ptr简单示例二........PS:函数体内定义类- - 不习惯吧,但不可以实现函数。。
		struct posix_file       //一个示范性质的文件类
		{
			posix_file(const char * file_name)   //构造函数打开文件
			{
				cout << "poen file:" << file_name << endl;
			}

			~posix_file()       //析构函数关闭文件
			{
				cout << "close file" << endl;
			}
		};

		scoped_ptr<int>p(new int);    //一个int指针的scoped_ptr

		if (p)                  //在bool语境中测试指针是否有效
		{
			*p = 100;           //可以像普通指针一样使用解引用操作符*
			cout << *p << endl;
		}

		p.reset();            //reset()置空scoped_ptr,仅仅是演示
		assert(p == 0);       //P不持有任何指针
		if (!p)               //在bool语境中测试，可以用！操作符
		{
			cout << "scoped_ptr==null" << endl;
		}

		//文件类的scoped_ptr,将在离开作用域时自动析构，从而关闭文件释放资源
		scoped_ptr<posix_file> fp(new posix_file("/tmp/a.txt"));
		//在离开作用域时发生scoped_ptr的析构，p和fp管理的指针自动被删除。

	}


	{
		//scoped_ptr与auto_ptr区别示例：
		auto_ptr<int>ap(new int(10));    //一个int 自动指针
		scoped_ptr<int>sp(ap);           //从auto_ptr获取原始指针
		assert(ap.get() == 0);           //原auto_ptr不再拥有指针

		ap.reset(new int(200));         //auto_ptr拥有新的指针
		cout << *ap << "," << *sp << endl;

		auto_ptr<int>ap2;
		ap2 = ap;            //ap2 从ap获得原始指针，发生所有权转移
		assert(ap.get() == 0); //ap不再拥有指针
		scoped_ptr<int> sp2;   //另一个scoped_ptr
		//sp2 = sp;				//赋值操作，无法通过编译！！

	}
	
	return false;
}

//scoped_array很像scoped_ptr, 它包装了new[]操作符。
bool scoped_array_fun()
{
	{
		int *arr = new int[100];   //一个整数的动态数组
		scoped_array<int>sa(arr);  //scoped_array对象代理原始动态数组

		//fill_n(&sa[0], 100, 5);    //可以使用标准库算法赋值数据
		
		sa[10] = sa[20] + sa[30];  //用起来就像是普通数组
	}
	

	return 0;
}



void print_func(boost::shared_ptr<int>p) //使用shared_ptr作为函数参数
{
	//同样输出shared_ptr的引用计数和指向的值
	cout << "count:" << p.use_count()
		<< " v =" << *p << endl;
}
//shared_ptr智能指针，已被纳入C++11标准中，非常有价值，非常重要，非常有用。
bool shared_ptr_fun()
{
	{  //shared_ptr简单测试
		std::shared_ptr<int> spp(new int); //C++11标准库中的shared_ptr
		boost::shared_ptr<int>spi(new int); //boost库中一个int 的shared_ptr

		assert(spi);   //在bool语境中隐式转换为bool值
		*spi = 253;    //使用解引用操作符*

		boost::shared_ptr<string> sps(new string("smart"));  //一个string的shared_ptr
		assert(sps->size() == 5);							//使用箭头操作符->
	}

	{ //shared_ptr用法例子：
		boost::shared_ptr<int>sp(new int(10)); //一个指向整数的shared_ptr
		assert(sp.unique());				//现在shared_ptr是指针的唯一持有者
		boost::shared_ptr<int> sp2 = sp;	        //第二个shared_ptr，拷贝构造函数
		//两个shared_ptr相等，指向同一个对象,引用计数为2
		assert(sp == sp2&&sp.use_count() == 2);

		*sp2 = 100;					//使用解引用操作符修改被指对象
		assert(*sp == 100);			//另一个shared_ptr也同时被修改
		sp.reset();                 //停止shared_ptr的使用
		assert(!sp);                //sp不再持有任何指针（空指针）

}

	{
		//shared_ptr用法例子二定义：
		class shared                //一个拥有shared_ptr的类
		{
		private:
			boost::shared_ptr<int>p; //shared_ptr成员变量
		public:
			shared(boost::shared_ptr<int>p_) :p(p_){
				cout << "*p构造测试" << p.use_count() << "*p=" << *p << endl;
			}   //构造函数初始化shared_ptr
			void print()
			{
				cout << "count:" << p.use_count()
					<< " v =" << *p << endl;
			}
		};
		//shared_ptr用法例子二调用：
		boost::shared_ptr<int>p(new int(100));

		shared s1(p), s2(p);     //构造两个自定类
		s1.print();
		s2.print();

		*p = 20;   //修改shared_ptr所指的值
		print_func(p);
		s1.print();

	}

	{
		//shared_ptr应用于标准容器的用法
		typedef vector<boost::shared_ptr<int>>vs;  //一个持有shared_ptr的标准容器类型
		vs v(10);               //声明一个拥有10个元素的容器，元素被初始化为空指针

		int i = 0;
		for (vs::iterator pos = v.begin(); pos != v.end(); ++pos)
		{
			(*pos) = make_shared<int>(++i);  //使用工厂函数赋值
			cout << *(*pos) << ", ";   //输出值
		}
		cout << endl;
		boost::shared_ptr<int>p = v[9];
		*p = 100;
		cout << *v[9] << endl;
	}
		


	return 0;
}

//mkae_shared用法示例，以取代new操作符。
void make_shared_fun()
{
	boost::shared_ptr<string>sp =
		boost::make_shared<string>("make_shared");   //创建string的共享指针
	boost::shared_ptr<vector<int>>spv =
		boost::make_shared<vector<int>>(10, 2);     //创建 vector的共享指针

	assert(spv->size() == 10);
}

//桥接模式的应用示例：
class sample
{
private:
	class impl;
	boost::shared_ptr<impl>p;
public:
	sample();
	void print();	
};

class sample::impl
{
public:
	void print()
	{
		cout << "impl print" << endl;
	}
	
};
sample::sample() :p(new impl){}
void sample::print()
{
	p->print();
}
//函数调用
void impl_fun()
{
	sample s;
	s.print();
}


//shared_ptr工厂模式应用测试:
class abstract
{
public :
	virtual void f() = 0;
	virtual void g() = 0;
protected:
	virtual ~abstract(){}    //注意这里
};

class impl:public abstract
{
public:
	virtual void f()
	{
		cout << "class impl f" << endl;
	}
	virtual void g()
	{
		cout << "class impl g" << endl;
	}
	
};
boost::shared_ptr<abstract>create()
{
	return boost::shared_ptr<abstract>(new impl);
}
void shared_ptr_create_fun()
{
	boost::shared_ptr<abstract> p = create();   //工厂函创建对象
	p->f(); //可以像普通指针一样使用
	p->g(); //不必担心资源汇漏
}

//删除器调用的任意函数示例
void any_func(void *p)
{
	cout << "some operate" << endl;
}



//shared_array 指针示例：
void shared_array_fun()
{
	int *p = new int[100];
	shared_array<int>sa(p);
	shared_array<int>sa2 = sa;
	sa[0] = 10;
	assert(sa2[0] == 10);
}

// weak_ptr智能指针示例。
void weak_ptr_fun()
{
	boost::shared_ptr<int> sp(new int(10));  //一个shared_prt
	assert(sp.use_count() == 1);
	
	boost::weak_ptr<int>wp(sp);       //从shared_ptr  创建weak_prt
	assert(wp.use_count() == 1);      //weak_ptr不影响引用计数

	if (!wp.expired())         //判断 weak_ptr观察的对象是否失效
	{
		boost::shared_ptr<int> sp2 = wp.lock();   //获得一个shared_ptr
		*sp2 = 100;
		assert(wp.use_count() == 2);
	}                              //退出作用域，SP2自动析构，引用计数减1

	assert(wp.use_count() == 1);
	sp.reset();              //shared_ptr失效
	assert(wp.expired());
	assert(!wp.lock());      //weak_ptr将获得一个空指针
}


//获取this的shared_ptr示例：
class self_shared :public boost::enable_shared_from_this<self_shared>
{
public:
	self_shared(int n) :x(n){}
	int x;
	void print()
	{
		cout << "self_shared:" << x << endl;
	}
};
void weak_ptr_this_fun()
{
	boost::shared_ptr<self_shared>sp = make_shared<self_shared>(314);
	sp->print();
	boost::shared_ptr<self_shared>p = sp->shared_from_this();
	p->x = 1000;
	p->print();
}

//pool内存池使用示例：
//struct demo_class
//{
//public:
//	int a, b, c;
//	demo_class(int x = 1, int y = 2, int z = 3) :a(x), b(y), c(z){}
//
//};
//void pool_fun()
//{
//	boost::object_pool<demo_class>pl;
//	
//
//	demo_class *p = pl.malloc();
//	assert(pl.is_from(p));
//
//	//P指向的内存未经过初始化
//	assert(p->a != 1 || p->b != 2 || p->c != 3);
//	p = pl.construct(7, 8, 9);
//	assert(p->a == 7);
//
//	boost::object_pool<string>pls;
//	for (int i = 0; i < 10; ++i)
//	{
//		string *ps = pls.construct("hello object_pool");
//		cout << *ps << endl;
//	}
//}
int main()
{
	scoped_ptr_fun();
	scoped_array_fun();
	shared_ptr_fun();
	make_shared_fun();
	impl_fun();

	//shared_ptr删除器, 例如操作资源一
	//boost::shared_ptr<FILE> fp(fopen("./1.txt", "r"), fclose);
	//shared_ptr删除器的另一种方法，退出作用域时调用任意函数。
	boost::shared_ptr<void>p((void*)0, any_func);  //容纳空指针，定制删除器，
													//退出作用域时将执行any_func()
	//智能数组指针
	shared_array_fun();

	//weak_ptr智能指针调用：
	weak_ptr_fun();

	//获取this的shared_ptr示例调用:
	weak_ptr_this_fun();

	//内存池pool
	/*pool_fun();*/

	system("pause");
	
	return 0;
}