STL之auto_ptr智能指针

auto_ptr是这样一种指针，它是“它所指向的对象”的拥有者，所以，当身为对象拥有者的auto_ptr被摧毁时，该对象也将遭到摧毁。auto_ptr要求一个对象只能有一个拥有者，严禁一物二主。

设计动机：

1获取一些资源

2执行一些动作

3释放所获取的资源，不用自己调用delete，不用担心异常。。。的原因，导致内存泄漏的问题了。

#include<iostream>
#include<memory>
#include<string>
using namespace std;
int main(){
auto_ptr<int>p(new int(8));
cout<<*p<<endl;

auto_ptr<string>pp(new string);
*pp="hello";
cout<<*pp<<endl;

auto_ptr<double>ppp(new double(1.23));
cout<<*ppp<<endl;

return 0;
}

#include<iostream>
#include<string>
#include<memory>
using namespace std;
int main(){
char *p="hello";
cout<<p<<endl;

int *pp=new int(100);
cout<<*pp<<endl;

char *ppp=new char('a');
cout<<*ppp<<endl;

char *ap=new char;
//string s1="hello";
//ap=&s1[0];
ap="hello";
cout<<ap<<endl;

return 0;
}

#include<iostream>
#include<string>
#include<memory>
using namespace std;
int main(){
auto_ptr<int>ap1(new int(100));
cout<<*ap1<<endl;
auto_ptr<int>ap2(new int);
*ap2=10086;
cout<<*ap2<<endl;

ap1=ap2;
cout<<*ap1<<endl;//输出10086
cout<<*ap2<<endl;//输出10086
return 0;
}
#include<iostream>
#include<memory>
#include<string>
using namespace std;
int main(){
auto_ptr<int>ap1(new int(10086));
auto_ptr<int>ap2(ap1);
cout<<*ap1<<endl;//转移拥有权,因此此句报错，注意在VC6.0是不报错的，VC对STL支持不那么好
cout<<*ap2<<endl;

auto_ptr<int>ap3(new int(10087));
auto_ptr<int>ap4;
ap4=ap3;
cout<<*ap3<<endl;//转移拥有权,因此此句报错,VS2008报错，VC6.0能运行，建议使用VS
cout<<*ap4<<endl;

//auto_ptr<int>ap5;
//ap5=new int(10088); //auto_ptr指针不能用普通指针初始化
//cout<<*ap5<<endl;
return 0;
}

#include<iostream>
#include<string>
#include<memory>
using namespace std;
void show(auto_ptr<int>p){
cout<<*p<<endl;
}
int main(){
auto_ptr<int>p(new int(10086));
show(p);
//cout<<*p<<endl;已经转移拥有权了
system("pause");
return 0;
}

const auto_ptr<int>p(new int(10086));

auto_ptr<int>pp(p); //这是错误的，因为const auto_ptr<type>x的拥有权不能能被更改

#include<iostream>
#include<memory>
using namespace std;
template<typename T>
ostream& operator<<(ostream& out,const auto_ptr<T>& p){
if(p.get()==NULL){
out<<"NULL";
}else{
out<<*p;
}
return out;
}
int main(){
auto_ptr<int>p(new int(42));
auto_ptr<int>q;
cout<<"after initialization:"<<endl;
cout<<"P:"<<p<<endl;
cout<<"Q:"<<q<<endl;

q=p;
cout<<"P:"<<p<<endl;
cout<<"Q:"<<q<<endl;

*q+=13;
cout<<"after change and reassignment:"<<endl;
cout<<"P:"<<p<<endl;
cout<<"Q:"<<q<<endl;

system("pause");
return 0;
}

#include<iostream>
#include<memory>
using namespace std;
template<typename T>
ostream& operator<<(ostream& out,const auto_ptr<T>& p){
if(p.get()==NULL){
out<<"NULL";
}else{
out<<*p;
}
return out;
}
int main(){

const auto_ptr<int>p(new int(42));
const auto_ptr<int>q(new int(0));
const auto_ptr<int>r;

cout<<"after initialization:"<<endl;
cout<<"p:"<<p<<endl;
cout<<"q:"<<q<<endl;
cout<<"r:"<<r<<endl;

*q=*p;
*p=-77;

cout<<"after assigning values"<<endl;
cout<<"p:"<<*p<<endl;
cout<<"q:"<<*q<<endl;
cout<<"r:"<<r<<endl;
system("pause");
return 0;
}

const int *p不可以改变他的指针，但是可以改变指针对应的值 如*p=100;

auto_ptr源码如下

namespace std{
	template<typename Y>
	struct auto_ptr_ref{};
	template<typename T>
	class auto_ptr{
	public:
		typedef T element_type;    //类型
		explicit auto_ptr(T* ptr=0) throw();//显示调用构造函数，不抛出任何异常
		auto_ptr(auto_ptr&)throw();   //拷贝构造函数
		template<typename U>
		auto_ptr(auto_ptr<U>&)throw();   //拷贝构造函数
		auto_ptr& operator=(auto_ptr&)throw();  //=操作符重载
		template<typename U>
		auto_ptr& operator=(auto_ptr<U>&)throw();  //=操作符重载
		~auto_ptr()throw();            // 析构函数

		T* get() const throw();   //获取元素指针
		T& operator*() const throw(); // 解析，获得元素
		T* operator->()const throw(); // 获得元素
		T* release() throw();		//释放
		void reset(T* ptr=0)throw();  //重置指针为0
	public:
		auto_ptr(auto_ptr_ref<T> rhs)throw();
		auto_ptr& operator=(auto_ptr_ref<T> rhs)throw();
		template<typename U>
		operator auto_ptr_ref<U>() throw();
		template<typename U>
		operator auto_ptr<U>() throw();

	};
}