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();

	};
}