C++:auto_ptr智能指针的用法

本文详细介绍了C++中的auto_ptr智能指针的使用方法及其原理,包括构造函数、析构函数、成员函数等,并通过示例对比了使用auto_ptr前后代码的安全性,帮助读者理解如何正确使用auto_ptr来避免内存泄漏。

转自: http://blog.youkuaiyun.com/monkey_d_meng/article/details/5901392

C++中指针申请和释放内存通常采用的方式是new和delete。然而标准C++中还有一个强大的模版类就是auto_ptr,它可以在你不用的时候自动帮你释放内存。下面简单说一下用法。

用法一:  
std::auto_ptr<T>m_example(new T());  

用法二:  
std::auto_ptr<T>m_example;  
m_example.reset(new T());  

用法三(指针的赋值操作):  
std::auto_ptr<T>m_example1(new T);  
std::auto_ptr<T>m_example2(new T);  
m_example2=m_example1;

则C++会把m_example所指向的内存回收,使m_example1 的值为NULL,所以在C++中,应绝对避免把auto_ptr放到容器中。即应避免下列代码:

vector<auto_ptr<T>>m_example;

当用算法对容器操作的时候,你很难避免STL内部对容器中的元素实现赋值传递,这样便会使容器中多个元素被置位NULL,而这不是我们想看到的,具体原因见为什么auto_ptr智能指针不能放在vector

虽然,标准auto_ptr智能指针机制很多人都知道,但很少使用它。这真是个遗憾,因为auto_ptr优雅地解决了C++设计和编码中常见的问题,正确地使用它可以生成健壮的代码。本文阐述了如何正确运用auto_ptr来让你的代码更加安全——以及如何避免对auto_ptr危险但常见的误用,这些误用会引发间断性发作、难以诊断的bug。

auto_ptr所做的事情,就是动态分配对象以及当对象不再需要时自动执行清理。这里是一个简单的代码示例,没有使用auto_ptr所以不安全:

// 示例1(a):原始代码    
void f()  
{  
      T* pt( new T );  
      /*...更多的代码...*/  
      delete pt;  
}  

我们大多数人每天写类似的代码。如果f()函数只有三行并且不会有任何意外,这么做可能挺好的。但是如果f()从不执行delete语句,或者是由于过早的返回,或者是由于执行函数体时抛出了异常,那么这个被分配的对象就没有被删除,从而我们产生了一个经典的内存泄漏。

能让示例1(a)安全的简单办法是把指针封装在一个“智能的”类似于指针的对象里,这个对象拥有这个指针并且能在析构时自动删除这个指针所指的对象。因为这个智能指针可以简单的当成一个自动的对象(这就是说,它出了作用域时会自动毁灭),所以很自然的把它称之为“智能”指针。

// 示例1(b):安全代码,使用了auto_ptr  
void f()  
{  
      auto_ptr<T> pt( new T );  
      /*...更多的代码...*/  
} // 酷:当pt出了作用域时析构函数被调用,从而对象被自动删除

现在代码不会泄漏T类型的对象,不管这个函数是正常退出还是抛出了异常,因为pt的析构函数总是会在出栈时被调用,清理会自动进行。

最后,使用一个auto_ptr就像使用一个内建的指针一样容易,而且如果想要“撤销”资源,重新采用手动的所有权,我们只要调用release()。

// 示例2:使用一个auto_ptr  
void g()  
{  
      // 现在,我们有了一个分配好的对象  
      T* pt1 = new T;  
      // 将所有权传给了一个auto_ptr对象  
      auto_ptr<T> pt2(pt1);  
      // 使用auto_ptr就像我们以前使用简单指针一样,  
      *pt2 = 12;    // 就像*pt1 = 12  
      pt2->SomeFunc();   // 就像pt1->SomeFunc();  
      // 用get()来获得指针的值  
      assert( pt1 == pt2.get() );  
      // 用release()来撤销所有权  
      T* pt3 = pt2.release();  //把包含的指针返回  
      // 自己删除这个对象,因为现在没有任何auto_ptr拥有这个对象  
      delete pt3;  
} // pt2不再拥有任何指针,所以不要试图删除它...OK,不要重复删除  

最后,我们可以使用auto_ptr的reset()函数来重置auto_ptr使之拥有另一个对象。如果这个auto_ptr已经拥有了一个对象,那么,它会先删除已经拥有的对象,因此调用reset()就如同销毁这个auto_ptr,然后新建一个并拥有一个新对象:

// 示例 3:使用reset()  
void h()  
{  
      auto_ptr<T> pt( new T(1) );  
      pt.reset( new T(2) );         // 删除由"new T(1)"分配出来的第一个T  
} // 最后pt出了作用域,第二个T也被删除了

auto_ptr用法:

  1. 需要包含头文件。

  2. Constructor:explicit auto_ptr(X* p = 0) throw(); //将指针p交给auto_ptr对象托管。

  3. Copy constructor:auto_ptr(const auto_ptr&) throw(); template auto_ptr(const auto_ptr& a) throw(); //指针的托管权会发生转移。

  4. Destructor: ~auto_ptr(); //释放指针p指向的空间。

  5. 提供了两个成员函数 X* get() const throw(); //返回保存的指针

  6. 对象中仍保留指针 X* release() const throw(); //返回保存的指针,对象中不保留指针

auto_ptr实现关键点:

  1. 利用特点“栈上对象在离开作用范围时会自动析构”。

  2. 对于动态分配的内存,其作用范围是程序员手动控制的,这给程序员带来了方便但也不可避免疏忽造成的内存泄漏,毕竟只有编译器是最可靠的。

  3. auto_ptr通过在栈上构建一个对象a,对象a中wrap了动态分配内存的指针p,所有对指针p的操作都转为对对象a的操作。而在a的析构函数中会自动释放p的空间,而该析构函数是编译器自动调用的,无需程序员操心。

多说无益,看一个最实用的例子:

#include <iostream>  
#include <memory>  
using namespace std;  
class TC  
{  
      public:  
             TC(){cout<<"TC()"<<endl;}  
             ~TC(){cout<<"~TC()"<<endl;}  
};  
void foo(bool isThrow)  
{  
     auto_ptr<TC> pTC(new TC);    // 方法2  
     //TC *pTC = new TC;    // 方法1  
     try  
     {  
                  if(isThrow)  
                        throw "haha";  
     }  
     catch(const char* e)  
     {  
                 //delete pTC;           // 方法1  
                 throw;  
     }  
     //delete pTC;          // 方法1  
} 
int main()  
{  
    try  
    {  
          foo(true);  
    }  
    catch(...)  
    {  
         cout<<"caught"<<endl;  
    }  
} 

1.如果采用方案1,那么必须考虑到函数在因throw异常的时候释放所分配的内存,这样造成的结果是在每个分支处都要很小心的手动 delete pTC;。

2.如果采用方案2,那就无需操心何时释放内存,不管foo()因何原因退出,栈上对象pTC的析构函数都将调用,因此托管在之中的指针所指的内存必然安全释放。

但是要注意使用中的一个陷阱,那就是指针的托管权是会转移的。例如在上例中,如果 auto_ptr pTC(new TC); auto_ptr pTC1=pTC; 那么,pTC1将拥有该指针,而pTC没有了,如果再用pTC去引用,必然导致内存错误。

要避免这个问题,可以考虑使用采用了引用计数的智能指针,例如boost::shared_ptr等。auto_ptr不会降低程序的效率,但auto_ptr不适用于数组,auto_ptr根本不可以大规模使用。 shared_ptr也要配合weaked_ptr,否则会很容易触发循环引用而永远无法回收内存。

理论上,合理使用容器加智能指针,C++可以完全避免内存泄露,效率只有微不足道的下降(中型以上程序最多百分之一)。

<think>好的,用户想了解std::shared_ptr的使用方法,需要教程和C++示例。首先,我需要回忆一下std::shared_ptr的基本概念和特性。根据提供的引用资料,std::shared_ptr是通过引用计数来管理资源的智能指针,允许多个指针共享同一资源,当最后一个指针销毁时资源才会释放。 接下来,用户需要教程和示例,所以应该分步骤讲解如何创建、初始化、使用以及注意事项。首先,创建实例,用户可能想知道如何构造一个shared_ptr,比如使用make_shared或者直接构造。引用中提到了make_shared的例子,应该优先推荐这种方法,因为更高效。 然后,访问资源,用户需要知道如何通过*和->操作符来访问指针指向的对象,这部分在引用[1]里有示例,可以引用那个例子。同时,共享所有权的概念很重要,比如多个shared_ptr指向同一个对象时引用计数的变化,引用[3]里的控制块说明可以支持这一点。 另外,需要提到weak_ptr的作用,避免循环引用的问题,这在引用[2]和引用[3]中都有涉及。用户可能不知道循环引用的情况,所以需要举一个例子说明,比如两个类互相持有对方的shared_ptr,导致引用计数无法归零,从而内存泄漏,这时候weak_ptr就派上用场了。 然后,内存管理机制需要解释清楚,引用计数如何增减,何时释放资源。引用[3]中的控制块和计数器机制可以详细说明。最后,注意事项部分要包括避免循环引用、优先使用make_shared、不混合使用裸指针和智能指针等,这些都是常见的问题点。 在生成相关问题时,需要考虑用户可能进一步想知道的内容,比如与unique_ptr的区别、weak_ptr的使用场景、线程安全性等。这些都是围绕shared_ptr的常见问题,能帮助用户深入理解。 最后,确保所有LaTeX格式正确,行内公式用$...$,独立公式用$$...$$,但根据用户提供的示例,可能不需要数学公式,但代码示例要用正确的格式。检查引用的标记是否正确,每个引用来源末尾添加对应的标识,如[^1]、[^2]、[^3]。 总结回答结构:分为创建、访问、共享、循环引用示例、内存管理、注意事项,最后相关问题。每个部分结合引用中的知识点,给出代码示例,并确保引用标记正确。</think># std::shared_ptr 智能指针使用教程 ## 一、基本特性与创建方法 std::shared_ptrC++11 引入的智能指针,通过**引用计数机制**实现多实例共享资源。当最后一个 shared_ptr 被销毁时,资源自动释放[^3]。 **创建实例的两种方式**: ```cpp // 方式1:直接构造(不推荐,可能产生内存碎片) std::shared_ptr<int> p1(new int(10)); // 方式2:使用 make_shared(推荐,更高效) auto p2 = std::make_shared<std::string>("Hello"); ``` ## 二、资源访问与共享 1. **访问资源**: ```cpp std::cout << *p2 << std::endl; // 输出字符串值 p2->append(" World"); // 调用成员函数 ``` 2. **共享所有权**: ```cpp auto ptr1 = std::make_shared<int>(42); auto ptr2 = ptr1; // 引用计数+1 std::cout << ptr2.use_count(); // 输出2 ``` ## 三、循环引用问题与解决方案 **问题场景**: ```cpp class A { std::shared_ptr<B> b_ptr; }; class B { std::shared_ptr<A> a_ptr; }; // 创建循环引用导致内存泄漏 ``` **解决方案**: ```cpp class B { std::weak_ptr<A> a_weak; // 使用 weak_ptr 打破循环 }; ``` ## 四、内存管理机制 - **引用计数器**:每个 shared_ptr 关联一个控制块,记录当前共享实例数量 - **删除时机**:当 `use_count()` 归零时触发资源释放 ```cpp auto p = std::make_shared<double>(3.14); std::cout << p.use_count(); // 输出1 auto p_copy = p; std::cout << p.use_count(); // 输出2 ``` ## 五、使用注意事项 1. 优先使用 `make_shared` 创建实例(减少内存分配次数) 2. 避免与裸指针混用: ```cpp int* raw = new int(5); std::shared_ptr<int> p(raw); // 正确用法 // 错误:std::shared_ptr<int> p2(raw); // 导致双重释放 ``` 3. 通过 `reset()` 主动释放所有权: ```cpp p.reset(); // 引用计数-1,若归零则释放资源 ``` ## 六、完整示例 ```cpp #include <iostream> #include <memory> int main() { // 创建共享资源 auto sp1 = std::make_shared<std::vector<int>>(); sp1->push_back(10); // 共享所有权 auto sp2 = sp1; sp2->push_back(20); // 输出内容 for (auto num : *sp1) { std::cout << num << " "; // 输出 10 20 } return 0; } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值