C++智能指针模板类auto_ptr，unique_ptr,shared_ptr和weak_ptr

太过爱你忘了你带给我的痛 2022-11-20 10:57 133阅读 0赞

智能指针是行为类似指针的**类对象**。  
这三个智能指针模板（**auto\_ptr,unique\_ptr和shared\_ptr**）都定义了类似指针的对象，可以将new获得（直接或间接）的地址赋给这种 对象。当智能指针过期后，其**析构函数**使用delete来释放内存。因此，如果将new返回的地址赋给这些对象，将无需记住稍后释放内存：**在智能指针过期后，这些内存将自动被释放。**  
要创建智能指针对象，必须包含头文件**memory**，该文件模板定义。然后使用通常的模板语法来实例化所需类型的指针。例如，模板auto\_ptr包含如下的构造函数：

template <class X> class auto_ptr{
        
    public:
    	explicit auto_ptr(X* p = 0) throw();
    	...
    }

throw()意味着构造函数不会引发异常。

auto_ptr<double> pd(new double);//创建一个指向double类型的auto_ptr智能指针pd
    auto_ptr<string> pd(new string);//创建一个指向string类型的auto_ptr智能指针ps
    unique_ptr<string> pdu(new string);//创建一个指向double类型的unique_ptr智能指针pdu
    shared_ptr<string> pds(new string);//创建一个指向string类型的shared_ptr智能指针pss

智能指针模板位于std名称空间中，每个智能指针都放在一个代码块内，当离开代码块时，指针将过期。

#include <iostream>
    #include<string>
    #include<memory>
    using std::cout;
    using std::cin;
    using std::endl;
    using std::string;
    class Report
    {
        
    public:
    	Report(const string s) :str(s) {
        
    		cout << "Object created!\n" << endl;
    	}
    	~Report() {
        
    		cout << "Object deleted!" << endl;
    	}
    	void comment() const {
        
    		cout << str << endl;
    	}
    
    private:
    	string str;
    };
    
    
    int main(void) {
        
    
    	{
        
    		std::auto_ptr<Report> ps(new Report("using autp_ptr"));
    		ps->comment();
    	}
    	{
        
    		std::shared_ptr<Report> ps(new Report("using shared_ptr"));
    		ps->comment();
    	}
    	{
        
    		std::unique_ptr<Report> ps(new Report("using unique_ptr"));
    		ps->comment();
    	}
    
    	std::shared_ptr<double> pd;
    	double *p_reg = new double;
    
    	//pd = p_reg;//不允许,构造函数使用了explicit，关闭了隐式构造函数
    	pd = std::shared_ptr<double>(p_reg);//允许，显式构造函数
    
    	//std::shared_ptr<double> pshared = p_reg;//不允许，同上，隐式构造函数被关闭
    	std::shared_ptr<double> pshared(p_reg);//允许，显式构造
    
    	return 0;
    }

智能指针对象的很多方面都类似于常规指针，例如，ps是一个智能指针对象，则可以对它执行解引用操作（\*ps）、用它来访问结构成员（ps->puffIndex）、将它赋值给相同类型的常规指针。还可以将智能指针对象赋给另一个同类型的智能指针对象（有风险）。  
对三种智能指针对象来说，都应避免如下情况：

string vacation("test");
    shared_ptr<string> pvac(&vacation);//错误

pvac过期时，程序将把delete运算符用于非堆内存，这是错误的。

# 关于智能指针的注意事项 #

auto\_ptr的缺陷：

auto_ptr<string> ps (new string("I reigned lonely as a cloud"));
    auto<string> vocation;
    vocation  = ps;

如果ps和vocation是常规指针，则两个指针将指向同一个string对象。这是不能接受的，因为程序试图将一个对象删除两次，一次是ps过期时，一次是vocation过期时。  
解决办法：

*  定义赋值运算符，使之执行深复制、深拷贝。这样两个指针将指向不同的对象，其中一个是另一个的副本。
 *  建立所有权（ownership）概念。对于特定的对象，只能有一个智能指针拥有它。这样只有拥有对象的智能指针的构造函数会删除对象。然后，让赋值操作转让所有权。这就是auto\_ptr和unique\_ptr的策略。但unique\_ptr的策略更严格。
 *  创建智能更高的指针，跟踪引用特定对象的指针计数。称为引用计数。例如，赋值时计数加一，而指针过期时计数减一，仅当最后一个指针过期时，才调用delete，这就是shared\_ptr的策略。

# unique\_ptr为何优于auto\_ptr #

auto_ptr<string> p1(new string("auto");//#1
    auto_ptr<string> p2;                             //#2
    p2=p1;                                                //#3

在语句\#3中，p2接管string对象的所有权，p1的所有权被剥夺，这可以防止p1和p2的析构函数试图删除同一个对象：但是如果程序随后试图使用p1，这将产生错误，因为p1不再指向有效的数据。  
unique\_ptr的情况：

unique_ptr<string> p1(new string("auto");//#4
    unique_ptr<string> p2;                   //#5
    p2=p1;                                 //#6

编译器会认为\#6语句非法，从而避免了p1不再指向有效数据的问题，因此unique\_ptr比auto\_ptr更安全。（**编译阶段发现错误比程序运行时出错更安全**）  
有时候如果前一个指针会很快地被销毁，这就不会留下危险，比如在函数中作为返回值：

unique_ptr<string> demo(const char *s){
        
    	unique_ptr<string> temp(new string(s));
    	return temp;
    }

假设：

unique_ptr<string> ps;
    ps = demo("Uniquely special");

demo返回的unique\_ptr在赋值给ps后，被销毁。ps接管string对象的所有权。  
总之，程序试图讲一个unique\_ptr赋给另一个时，如果unique\_ptr是临时右值，则允许，如果源unique\_ptr将存在一段时间，则编译器不允许。

unique_ptr<string> pu1(new string("hello");//#1
    unique_ptr<string> pu2;                   //#2
    pu2=pu1;                                 //#3  不允许
    unique_ptr<string> pu3;                   //#4
    pu3 = unique_ptr<string>(new string("Hi"); //#5 允许,临时对象将会被销毁

如果非要执行\#3这个语句，仅当以非智能的方式使用遗弃的智能指针（如解引用时），这种赋值才会不安全。要安全地重用这种指针。可以给它赋新值。**C++有一个标准库函数std::move()，可以实现将一个unique\_ptr赋值给另一个**。

unique_ptr<string>ps1,ps2;//#1
    ps1=demo("Uniquely special");   
    ps2 = std::move(ps1);
    ps1=demo("TEST");   
    cout<<*ps2<<*ps1<<endl;

相对于auto\_ptr,unique\_ptr还有另外一个优点。模板auto\_ptr只能使用new和delete，而unique\_ptr可以使用new和new\[\].

> 使用new分配内存时，才能使用auto\_ptr和shared\_ptr，使用new\[\]时，不能  
> unique\_ptr则可以使用new和new \[ \].  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1b2xhaWh1YTIwMTg_size_16_color_FFFFFF_t_70_pic_center]

# 选择智能指针 #

*  如果程序要使用多个指向同一个对象的指针，应选择shared\_ptr。因为它有引用计数。
 *  如果不需要，就使用unique\_ptr。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2x1b2xhaWh1YTIwMTg_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/26e4d291d8fd46b6a835af88843a6cb9.png