c++智能指针的理解

「爱情、让人受尽委屈。」 2022-06-02 06:15 392阅读 0赞

## 写在前面： ##

智能指针的运用是c++里很重要的一个方面。

## 主要的理解： ##

智能指针是为了更容易的动态的管理和使用动态内存而设计的，新的标准库提供两种智能指针。  
一个是shared\_ptr 允许多个指针指向同一个对象  
一个是unique\_ptr 独占所指向的对象。  
还有一种伴随类 weak\_ptr 他是一种弱引用 指向shared\_ptr所指向的对象。  
这些类型都定义在memory头文件当中。

智能指针类似容器也是模板，当我们创建一个智能指针时候也需要给出指针所指向的对象的类型，这个在智能指针的模板参数当中给出。

shared_ptr<string> p;

这就是声明了一个指向string类型的智能指针 默认初始化的智能指针保存的是一个空指针（默认无参构造函数）。智能指针的使用和一般的指针是一样的，解引用操作符使得返回指针指向的对象。条件判断一个指针就是判断这个指针是否为空。  
智能指针一样支持指针的->获得成员变量指向成员函数的操作符。（都已经重载）

智能指针支持所有一般指针的操作但是也具备智能指针独有的操作：

make_shared<T>(args) 返回一个shared_ptr指向一个类型为T的对象，使用args初始化对象
    shared_ptr<T>p(q) p是q的拷贝 q的计数器增加、
    p = q 递减p的计数器 递增q的计数器
    p.unique()
    p.use_count()

最安全的分配和使用动态内存的额方式是使用make\_shared的标准库函数、  
这个函数在定义一个动态指针的同时分配一个对象并且初始化他  
使用一个auto 对象来保存make\_shared 的结果这种方式比较简单

## 计数器概念 ##

每一个shared\_ptr都有一个与之相关联的计数器称为引用计数器。  
无论何时我们拷贝一个shared\_ptr都会使得计数器递增。  
当时用一个智能指针去初始化另一个智能指针的时候  
当讲其作为一个参数传递给一个函数的时候  
作为函数返回值的时候  
所关联的计数器就会增加。

当我们给一个shared\_ptr 赋予一个新的值的时候  
或者当前的智能指针被销毁 （离开其作用域）  
计数器就会减一

一旦一个智能指针的计数器变为0 那么就会自动的释放自己所管理的对象  
当销毁此对象的时候是通过析构函数完成销毁的工作。  
析构函数就是释放对象分配的资源  
智能指针的析构函数会递减指向对象的引用计数，如果引用计数变为0 智能指针的析构函数就会销毁该对象  
释放其占有的内存。

## auto\_ptr ##

**一个简易、通用的智能指针，它不包含所有的小技巧，不像专用的或高性能的智能指针那么奢华，但是它可以很好的完成许多普遍的工作，它很适合日常性的使用。**

auto\_ptr所做的事情，就是动态分配对象以及当对象不再需要时自动执行清理。

void f()  
    {  
    T* pt( new T );  
    ...... 
          delete pt;  
    }

如果f()函数只有三行并且不会有任何意外，这么做可能挺好的。  
但是如果f()从不执行delete语句，或者是由于过早的返回，或者是由于执行函数体时抛出了**异常**，那么这个被分配的对象就没有被删除，从而我们产生了一个经典的**内存泄漏**。  
这里采用的是new的方式构造那么是在堆上构造的只有显示的调用delete才能析构该对象 否则永远都不能释放该对象的内存。

解决方案：能让示例安全的简单办法是把指针封装在一个“智能的”类似于指针的对象里，这个对象拥有这个指针并且能在析构时自动删除这个指针所指的对象。因为这个智能指针可以简单的当成一个自动的对象（**它出了作用域时会自动毁灭**），所以很自然的把它称之为“智能”指针。

void f()  
    {  
    auto_ptr<T> pt( new T );  
    。。。。。。
    } // 当pt出了作用域时析构函数被调用，从而对象被自动删除

现在代码不会泄漏T类型的对象，不管这个函数是正常退出还是抛出了异常，**因为pt的析构函数总是会在出栈时被调用**，清理会自动进行。  
最后，使用一个auto\_ptr就像使用一个内建的指针一样容易，而且如果想要“撤销”资源，重新采用手动的所有权，我们只要调用release()。  
现在将new的对象使用一个智能指针进行管理，智能指针在离开作用域，出栈的时候会自动调用析构函数，析构所指向的对象。

auto\_ptr实现关键点：  
1. 利用特点“栈上对象在离开作用范围时会自动析构”。  
2. 对于动态分配的内存，其作用范围是程序员手动控制的，这给程序员带来了方便但也不可避免疏忽造成的内存泄漏，毕竟只有编译器是最可靠的。  
3. auto\_ptr通过在栈上构建一个对象a，对象a中wrap了动态分配内存的指针p，所有对指针p的操作都转为对对象a的操作。而在a的析构函数中会自动释放p的空间，而该析构函数是编译器自动调用的，无需程序员操心。

不要误用auto\_ptr

1）auto\_ptr不能共享所有权，即不要让两个auto\_ptr指向同一个对象。

2）auto\_ptr不能指向数组，因为auto\_ptr在析构的时候只是调用delete,而数组应该要调用delete\[\]。

3）auto\_ptr只是一种简单的智能指针，如有特殊需求，需要使用其他智能指针，比如share\_ptr。

4）auto\_ptr不能作为容器对象，STL容器中的元素经常要支持拷贝，赋值等操作，在这过程中auto\_ptr会传递所有权，那么source与sink元素之间就不等价了。

用法一：  
    std::auto_ptr<MyClass>m_example(new MyClass());  
    
    用法二：  
    std::auto_ptr<MyClass>m_example;  
    m_example.reset(new MyClass());  
    
    用法三（指针的赋值操作）：  
    std::auto_ptr<MyClass>m_example1(new MyClass());  
    std::auto_ptr<MyClass>m_example2(new MyClass());  
    m_example2=m_example1;

在C++中，应绝对避免把auto\_ptr放到容器中。即应避免下列代码：

vector<auto_ptr<MyClass>>m_example;

当用算法对容器操作的时候，你很难避免STL内部对容器中的元素实现赋值传递，这样便会使容器中多个元素被置位NULL，而这不是我们想看到的。

[http://blog.csdn.net/monkey\_d\_meng/article/details/5901392][http_blog.csdn.net_monkey_d_meng_article_details_5901392]  
**要避免这个问题，可以考虑使用采用了引用计数的智能指针，例如boost::shared\_ptr等。auto\_ptr不会降低程序的效率，但auto\_ptr不适用于数组，auto\_ptr根本不可以大规模使用。 shared\_ptr也要配合weaked\_ptr，否则会很容易触发循环引用而永远无法回收内存。 理论上，合理使用容器加智能指针，C++可以完全避免内存泄露，效率只有微不足道的下降（中型以上程序最多百分之一）。**

[http_blog.csdn.net_monkey_d_meng_article_details_5901392]: http://blog.csdn.net/monkey_d_meng/article/details/5901392