boost教程（二）：智能指针

每一部分都单独注释的，运行时取消注释，将其他部分注释起来就可以。

#include <boost/scoped_ptr.hpp> 
#include <boost/scoped_array.hpp> 
#include <boost/shared_array.hpp> 
#include <boost/timer/timer.hpp>
#include <boost/shared_ptr.hpp> 
#include <vector> 
#include <iostream>
#include <Windows.h>

#include <boost/weak_ptr.hpp> 
#include <boost/ptr_container/ptr_vector.hpp> 


DWORD WINAPI reset(LPVOID p)
{
	boost::shared_ptr<int> *sh = static_cast<boost::shared_ptr<int>*>(p);
	//reset() 线程在销毁对象的时候print() 线程可能正在访问它。
	sh->reset();
	return 0;
}

DWORD WINAPI print(LPVOID p)
{
	boost::weak_ptr<int> *w = static_cast<boost::weak_ptr<int>*>(p);
	//弱指针本身对于对象的生存期没有任何影响。
	//lock() 返回一个共享指针，print() 函数就可以安全的访问对象了
	boost::shared_ptr<int> sh = w->lock();
	if (sh)
		std::cout << *sh << std::endl;
	return 0;
}



int main()
{


	/*
	*************作用域指针
	一个作用域指针不能传递它所包含的对象的所有权到另一个作用域指针。
	一旦用一个地址来初始化，这个动态分配的对象将在析构阶段释放。
	可以避免不经意间的所有权传递。
	还有 get() 和 reset() 方法。 前者返回所含对象的地址，后者用一个新的对象来重新初始化智能指针。
	
	*/
	/*boost::scoped_ptr<int> i(new int);
	*i = 1;
	*i.get() = 2;
	i.reset(new int);*/


	/*
	**************作用域数组
	通过 operator[]() 操作符访问数组中特定的元素，
	提供了 get() 和 reset() 方法，
	*/
	/*boost::scoped_array<int> i(new int[2]);
	*i.get() = 1;
	i[1] = 2;
	i.reset(new int[3]);*/

	/*
	***********使用率最高的智能指针-共享指针
	boost::shared_ptr 不一定要独占一个对象。 它可以和其他 boost::shared_ptr 类型的智能指针共享所有权。
	当引用对象的最后一个智能指针销毁后，对象才会被释放。

	任何一个共享指针都可以被复制，
	这样就可以在标准容器里存储智能指针了
	*/
	//std::vector<boost::shared_ptr<int> > v;
	//v.push_back(boost::shared_ptr<int>(new int(1)));
	//v.push_back(boost::shared_ptr<int>(new int(2)));

	///*for (auto pos=v.begin();pos!=v.end();pos++)
	//{
	//	std::cout << *(*pos)<< std::endl;
	//}*/
	//std::cout << *(*(v.begin()+1)) << std::endl;
	访问元素注意小括号(不加小括号不得i型)
	//std::cout << *(v[0]) << std::endl;
	//std::cout << *(v[1]) << std::endl;
	
	

	/*
	boost::shared_ptr 类重载了以下这些操作符：operator*()，operator->() 和 operator bool()。
	*/
	//boost::timer::auto_cpu_timer t(8);   //计时
	/*boost::shared_ptr<int> i1(new int(1));
	boost::shared_ptr<int> i2(i1);
	i1.reset(new int(2));*/

	//Sleep(1000);
	//t.report();
	//std::cout << "格式：" << t.format_string() << std::endl; //输出：%w




	/*
	默认情况下，boost::shared_ptr 使用 delete 操作符来销毁所含的对象。
	然而，具体通过什么方法来销毁，是可以指定的，就像下面的例子里所展示的：
	*/
	/*boost::shared_ptr<void> h(OpenProcess(PROCESS_SET_INFORMATION, FALSE, GetCurrentProcessId()), CloseHandle);
	SetPriorityClass(h.get(), HIGH_PRIORITY_CLASS);*/




	//****************** 共享数组
	//所含对象的所有权可以跟其他共享数组来共享。
	/*boost::shared_array<int> i1(new int[2]);
	boost::shared_array<int> i2(i1);
	i1[0] = 1;
	std::cout << i2[0] << std::endl;*/



	//************弱指针
	/*
	基本上只提供一个有用的方法: lock()。此方法返回的boost::shared_ptr 
	与用来初始化弱指针的共享指针共享所有权。 如果这个共享指针不含有任何对象，返回的共享指针也将是空的。
	当函数需要一个由共享指针所管理的对象，而这个对象的生存期又不依赖于这个函数时，就可以使用弱指针。
	*/
	/*boost::shared_ptr<int> sh(new int(99));
	boost::weak_ptr<int> w(sh);
	HANDLE threads[2];
	threads[0] = CreateThread(0, 0, reset, &sh, 0, 0);
	threads[1] = CreateThread(0, 0, print, &w, 0, 0);
	WaitForMultipleObjects(2, threads, TRUE, INFINITE);*/





	//******************介入式指针(暂时不看)
	/*
	介入式指针的工作方式和共享指针完全一样。 boost::shared_ptr 在内部记录着引用到某个对象的共享指针的数量，
	可是对介入式指针来说，程序员就得自己来做记录。 对于框架对象来说这就特别有用，因为它们记录着自身被引用的次数。
	*/



	//*******************指针容器
	/*
	跟上面例子中用 boost::shared_ptr 模板参数来初始化的容器具有相同的工作方式。
	还包括：boost::ptr_deque， boost::ptr_list， boost::ptr_set， boost::ptr_map，
	boost::ptr_unordered_set 和 boost::ptr_unordered_map。
	*/
	/*boost::ptr_vector<int> v;
	v.push_back(new int(1));
	v.push_back(new int(2));
	
	//访问方式与上面的不同
	for (auto pos=v.begin();pos!=v.end();pos++)
	{
		std::cout << (*pos)<< std::endl;
	}
	
	std::cout << (v[0]) << std::endl;
	std::cout << (v[1]) << std::endl;*/
	
	system("pause");
	return 0;
}