什么是智能指针，什么时候应该使用智能指针？

Question

什么是智能指针，什么时候应该使用智能指针？

Answer 1

更新

这个答案相当陈旧，所以描述了当时什么是“好的”，这是由Boost库提供的智能指针。自从C++11以来，标准库已经提供了足够的智能指针类型，因此您应该倾向于使用std::unique_ptr、std::shared_ptr和std::weak_ptr。

还有std::auto_ptr。它非常像一个作用域指针，除了它还具有被复制的“特殊”危险能力--这也会意外地转移所有权。

它在C++11中已被弃用，并在C++17中被删除，因此您不应该使用它。

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.

旧答案

智能指针是一个包装“原始”(或“裸”) C++指针的类，用于管理所指向对象的生命周期。没有单一的智能指针类型，但它们都试图以一种实用的方式抽象原始指针。

智能指针应该优先于原始指针。如果你觉得你需要使用指针(如果你真的需要的话，首先考虑一下)，你通常会想要使用智能指针，因为这可以缓解原始指针的许多问题，主要是忘记删除对象和内存泄漏。

对于原始指针，当对象不再有用时，程序员必须显式地销毁该对象。

// 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...?

通过比较，智能指针定义了关于何时销毁对象的策略。您仍然需要创建对象，但您不必再担心销毁它。

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

使用中最简单的策略涉及智能指针包装对象的作用域，例如由boost::scoped_ptr或std::unique_ptr实现的对象。

void f()
{
    {
       std::unique_ptr<MyObject> ptr(new MyObject());
       ptr->DoSomethingUseful();
    } // ptr goes out of scope -- 
      // the MyObject is automatically destroyed.

    // ptr->Oops(); // Compile error: "ptr" not defined
                    // since it is no longer in scope.
}

请注意，不能复制std::unique_ptr实例。这可以防止指针被多次删除(不正确)。但是，您可以将对它的引用传递给您调用的其他函数。

当您想将对象的生命周期绑定到特定的代码块时，或者如果您将其作为成员数据嵌入到另一个对象中，则std::unique_ptr非常有用。该对象将一直存在，直到退出包含代码块，或者直到包含对象本身被销毁。

更复杂的智能指针策略涉及对指针进行引用计数。这确实允许复制指针。当对该对象的最后一个“引用”被销毁时，该对象将被删除。此策略由boost::shared_ptr和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.

当对象的生命周期非常复杂，并且不直接绑定到特定的代码段或另一个对象时，引用计数指针非常有用。

引用计数的指针有一个缺点-可能会创建悬空引用：

// 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!

另一种可能是创建循环引用：

struct Owner {
   std::shared_ptr<Owner> other;
};

std::shared_ptr<Owner> p1 (new Owner());
std::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!

为了解决这个问题，Boost和C++11都定义了一个weak_ptr来定义对shared_ptr的弱(未计数)引用。

Answer 2

对于如今的现代C++ (C++11及更高版本)，以下是一个简单的答案：

• "What是智能指针吗？“

它是一种可以像指针一样使用其值的类型，但它提供了自动内存管理的附加功能:当智能指针不再使用时，它所指向的内存将被释放(另请参阅the more detailed definition on Wikipedia).

• "When是否应该使用一个？“

在涉及跟踪一块内存的所有权、分配或释放的代码中，智能指针通常使您不必做这些事情，在哪种情况下我应该使用哪种智能指针？“

• std::unique_ptr，当您希望对象的生命周期与其拥有的引用的生命周期一样长。例如,使用它作为指向内存的指针，该内存在进入某个作用域时被分配，在退出作用域时被释放。当您确实想要从多个位置引用对象，并且不想在所有这些引用本身消失之前释放对象时，
• 使用std::shared_ptr。当您确实想要从多个位置引用对象时，
• 使用std::weak_ptr -对于那些可以忽略和释放的引用(这样，当您尝试dereference).
• Don时，它们只会注意到对象已经消失了除非在特殊情况下使用must.

，否则不要使用boost::智能指针或std::auto_ptr

我没有问我该用哪一个！“

啊，但是你真的想，承认it.

• "So，我应该在什么时候使用常规指针？“

主要是在与内存所有权无关的代码中。这通常发生在函数中，这些函数从其他地方获取指针，既不分配也不释放，也不存储超过其执行时间的指针副本。

Answer 3

smart pointer是一种类似指针的类型，具有一些附加功能，例如自动内存释放、引用计数等。

在Smart Pointers - What, Why, Which?页面上提供了一个小介绍。

简单的智能指针类型之一是std::auto_ptr ( C++标准的20.4.5章)，它允许在内存超出作用域时自动释放内存，并且在抛出异常时比简单的指针使用更健壮，尽管灵活性较差。

另一个方便的类型是boost::shared_ptr，它实现引用计数，并在没有对对象的引用时自动释放内存。这有助于避免内存泄漏，并且易于用于实现RAII。

这一主题在"C++ Templates: The Complete Guide" by David Vandevoorde, Nicolai M. Josuttis一书的第20章“智能指针”中有详细介绍。介绍了一些主题：

针对Exceptions

• Holders，的保护(注意，std::auto_ptr是这种类型的智能pointer)

• Resource Acquisition Is Initialization的实现(这通常用于C++中的异常安全资源管理)

• Holder Limitations

• Reference Counting

• Concurrent Counter Access

• Destruction和Deallocation