[Boost基础]内存管理——智能指针(二)

#include <iostream>
#include <string>
#include <conio.h>    
//1.作用域指针
//它独占一个动态分配的对象，对应的类名为boost::scoped_ptr,定义在boost/scoped_ptr.hpp中。
//不像std::auto_ptr,作用域指针不能传递它所包含的对象的所有权到另一个作用域指针。
//一旦用一个地址来初始化，这个动态分配的对象将在析构阶段释放。因为一个作用域指针只是简单保存
//和独占一个内存地址，所以boost::scoped_ptr的实现就要比std::auto_ptr简单。在不需要所有权
//传递的时候应该优先使用boost::scoped_ptr.在这些情况下，比起std::auto_ptr它是一个更好的
//选择，因为可以避免不经意间的所有权传递。因此我们通常可以用它来实现局部动态对象的自动
//释放，比如在函数调用中产生的动态对象。
#include <boost/scoped_ptr.hpp>
void test1()
{
	boost::scoped_ptr<int> p(new int);
	*p=1;
    *p.get()=2;
	p.reset(new int);
}
//2.作用域数组
//作用域数组的使用方式与作用域指针相似。关键不同在于，作用域数组的析构函数使用delete[]操作
//符来释放所包含的对象。因为该操作符只能用于数组对象，所以作用域数组必须通过动态分配数组
//来初始化。对应的作用域数组类名为boost::scoped_array，它的定义在boost/scoped_array.hpp里。
#include <boost/scoped_array.hpp>
void test2()
{
	boost::scoped_array<int> ap(new int[2]);
	*ap.get()=1;
	ap[1]=2;
	ap.reset(new int[3]);
}
//3.共享指针
//这个智能指针命名为boost::shared_ptr，定义在boost/shared_ptr.hpp里。智能指针
//boost::shared_ptr基本上类似于boost_scoped_ptr.关键不同之处在于boost::shared_ptr
//类型的智能指针共享所有权。在这种情况下，当引用对象的最后一个智能指针销毁后，对象
//才会释放。因为所有权可以在boost::shared_ptr之间共享，任何一个共享指针都可以被复
//制，这跟boost::scoped_ptr是不同的。这样就可以在标准容器里存储智能指针了——你不能再
//标准容器中存储std::suto_ptr，因为他们在拷贝的时候传递了所有权。
#include <vector>
#include <algorithm>
#include <boost/shared_ptr.hpp>
void myprint(boost::shared_ptr<int> i)
{
	printf("%d\n",*i);
}
void test3()
{
	std::vector<boost::shared_ptr<int>>v;
	boost::shared_ptr<int> s1(new int(1));
	boost::shared_ptr<int> s2(new int(2));
	v.push_back(s1);
	v.push_back(s2);
	std::for_each(v.begin(),v.end(),myprint);//输出 1 2
}
#include <stdio.h>
#include <stdlib.h>
class Test
{
public:
	Test(int i):_i(i){printf("test construct:%d\n",_i);}
	~Test(){printf("~test destroyed:%d\n",_i);}
	void myprint(){printf("test value:%d\n",_i);}
private:
	int _i;
};
void test4()
{
	boost::shared_ptr<Test> te1(new Test(1));//test construct:1
	boost::shared_ptr<Test> te2(te1);
	boost::shared_ptr<Test> te3(te1);
	te1.reset(new Test(2));//test construct:2
	te1->myprint();//test value:2
	te2->myprint();//test value:1
	te3->myprint();//test value:1
	//最后输出//~test destroyed:1
	//~test destroyed:2
} 
//4.共享数组
//共享数组的行为类似于共享指针。关键不同在于共享数组在析构是，默认使用的是delete[]操
//作符来释放所包含对象。因为这个操作符只能用于数组对象，共享数组必须通过动态分配的数组
//地址来初始化。共享数组对应的类型是boost::shared_array，它的定义在boost/shared_arrary.hpp里。
#include <boost/shared_array.hpp>
void test5()
{ 
	boost::shared_array<int> sa1(new int[2]);
	boost::shared_array<int> sa2(sa1);
	sa1[0]=1;
	std::cout<<sa2[0]<<"  "<<sa2[1]<<std::endl;//1 -84150451
} 
//对智能指针的良好运用可以有效处理内存，资源等自我管理释放问题。对于现代C++来说，
//是必不可少的一件"神器"。同时在boost库里面也有广泛应用，如在asio中，shared_ptr的
//使用就是其中一例。
void test(char t)
{
	std::cout<<"press key====="<<t<<std::endl;
	switch (t)
	{ 
 	case '1':test1();break;
 	case '2':test2();break;
 	case '3':test3();break;
 	case '4':test4();break;
 	case '5':test5();break; 
	case 27:
	case 'q':exit(0);break;
	default: std::cout<<"default "<<t<<std::endl;break;
	}
}
int main()
{
	while(1)
	{
		test(getch());
	} 
	return 0;
}