YaoRaoLov 2008-09-20 00:09 采纳率: 50%
浏览 484
已采纳

什么是智能指针,什么时候应该使用?

What is a smart pointer and when should I use one?

转载于:https://stackoverflow.com/questions/106508/what-is-a-smart-pointer-and-when-should-i-use-one

  • 写回答

14条回答 默认 最新

  • 叼花硬汉 2008-09-20 00:48
    关注

    A smart pointer is a class that wraps a 'raw' (or 'bare') C++ pointer, to manage the lifetime of the object being pointed to. There is no single smart pointer type, but all of them try to abstract a raw pointer in a practical way.

    Smart pointers should be preferred over raw pointers. If you feel you need to use pointers (first consider if you really do), you would normally want to use a smart pointer as this can alleviate many of the problems with raw pointers, mainly forgetting to delete the object and leaking memory.

    With raw pointers, the programmer has to explicitly destroy the object when it is no longer useful.

    // Need to create the object to achieve some goal
    MyObject* ptr = new MyObject(); 
    ptr->DoSomething(); // Use the object in some way
    delete ptr; // Destroy the object. Done with it.
    // Wait, what if DoSomething() raises an exception...?
    

    A smart pointer by comparison defines a policy as to when the object is destroyed. You still have to create the object, but you no longer have to worry about destroying it.

    SomeSmartPtr<MyObject> ptr(new MyObject());
    ptr->DoSomething(); // Use the object in some way.
    
    // Destruction of the object happens, depending 
    // on the policy the smart pointer class uses.
    
    // Destruction would happen even if DoSomething() 
    // raises an exception
    

    The simplest policy in use involves the scope of the smart pointer wrapper object, such as implemented by boost::scoped_ptr or std::unique_ptr.

    void f()
    {
        {
           boost::scoped_ptr<MyObject> ptr(new MyObject());
           ptr->DoSomethingUseful();
        } // boost::scopted_ptr goes out of scope -- 
          // the MyObject is automatically destroyed.
    
        // ptr->Oops(); // Compile error: "ptr" not defined
                        // since it is no longer in scope.
    }
    

    Note that scoped_ptr instances cannot be copied. This prevents the pointer from being deleted multiple times (incorrectly). You can, however, pass references to it around to other functions you call.

    Scoped pointers are useful when you want to tie the lifetime of the object to a particular block of code, or if you embedded it as member data inside another object, the lifetime of that other object. The object exists until the containing block of code is exited, or until the containing object is itself destroyed.

    A more complex smart pointer policy involves reference counting the pointer. This does allow the pointer to be copied. When the last "reference" to the object is destroyed, the object is deleted. This policy is implemented by boost::shared_ptr and std::shared_ptr.

    void f()
    {
        typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias
        MyObjectPtr p1; // Empty
    
        {
            MyObjectPtr p2(new MyObject());
            // There is now one "reference" to the created object
            p1 = p2; // Copy the pointer.
            // There are now two references to the object.
        } // p2 is destroyed, leaving one reference to the object.
    } // p1 is destroyed, leaving a reference count of zero. 
      // The object is deleted.
    

    Reference counted pointers are very useful when the lifetime of your object is much more complicated, and is not tied directly to a particular section of code or to another object.

    There is one drawback to reference counted pointers — the possibility of creating a dangling reference:

    // Create the smart pointer on the heap
    MyObjectPtr* pp = new MyObjectPtr(new MyObject())
    // Hmm, we forgot to destroy the smart pointer,
    // because of that, the object is never destroyed!
    

    Another possibility is creating circular references:

    struct Owner {
       boost::shared_ptr<Owner> other;
    };
    
    boost::shared_ptr<Owner> p1 (new Owner());
    boost::shared_ptr<Owner> p2 (new Owner());
    p1->other = p2; // p1 references p2
    p2->other = p1; // p2 references p1
    
    // Oops, the reference count of of p1 and p2 never goes to zero!
    // The objects are never destroyed!
    

    To work around this problem, both Boost and C++11 have defined a weak_ptr to define a weak (uncounted) reference to a shared_ptr.


    UPDATE

    This answer is rather old, and so describes what was 'good' at the time, which was smart pointers provided by the Boost library. Since C++11, the standard library has provided sufficient smart pointers types, and so you should favour the use of std::unique_ptr, std::shared_ptr and std::weak_ptr.

    There is also std::auto_ptr. It is very much like a scoped pointer, except that it also has the "special" dangerous ability to be copied — which also unexpectedly transfers ownership! It is deprecated in the newest standards, so you shouldn't use it. Use the std::unique_ptr instead.

    std::auto_ptr<MyObject> p1 (new MyObject());
    std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership. 
                                     // p1 gets set to empty!
    p2->DoSomething(); // Works.
    p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception.
    
    本回答被题主选为最佳回答 , 对您是否有帮助呢?
    评论
查看更多回答(13条)

报告相同问题?

悬赏问题

  • ¥15 MATLAB动图问题
  • ¥15 【提问】基于Invest的水源涵养
  • ¥20 微信网友居然可以通过vx号找到我绑的手机号
  • ¥15 寻一个支付宝扫码远程授权登录的软件助手app
  • ¥15 解riccati方程组
  • ¥15 display:none;样式在嵌套结构中的已设置了display样式的元素上不起作用?
  • ¥15 使用rabbitMQ 消息队列作为url源进行多线程爬取时,总有几个url没有处理的问题。
  • ¥15 Ubuntu在安装序列比对软件STAR时出现报错如何解决
  • ¥50 树莓派安卓APK系统签名
  • ¥65 汇编语言除法溢出问题