协慌网

 登录 贡献 社区

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

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

答案

智能指针是一个包装 “原始”（或 “裸”）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()
{
    {
       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.
}

请注意，无法复制scoped_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 {
   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!

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

UPDATE

这个答案相当陈旧，因此描述了当时的 “好”，这是 Boost 库提供的智能指针。从 C ++ 11 开始，标准库提供了足够的智能指针类型，因此您应该支持使用std::unique_ptr ， std::shared_ptr和std::weak_ptr 。

还有std::auto_ptr 。它非常像一个范围指针，除了它还具有 “特殊” 危险的复制能力 - 这也意外地转移了所有权！ 它在最新标准中被弃用，因此您不应该使用它。请改用std::unique_ptr 。 

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 ++ 的简单答案：

  • 什么是智能指针？
    它是一种类型，其值可以像指针一样使用，但它提供了自动内存管理的附加功能：当智能指针不再使用时，它指向的内存被释放（请参阅维基百科上更详细的定义 ）。
  • 我应该什么时候使用？
    在代码中涉及跟踪一块内存的所有权，分配或取消分配; 智能指针通常可以节省您明确执行这些操作的需要。
  • 但是我应该在哪些情况下使用哪个智能指针？
    • 当您不打算对同一对象持有多个引用时，请使用std::unique_ptr 。例如，将它用作指向内存的指针，该指针在进入某个范围时被分配，并在退出范围时被解除分配。
    • 当你想要从多个地方引用你的对象时，使用std::shared_ptr - 并且在所有这些引用本身都消失之前不希望它被解除分配。
    • 当你想从多个地方引用你的对象时，使用std::weak_ptr - 对于那些可以忽略和解除分配的引用（所以当你尝试取消引用时它们只会注意到对象已经消失）。
    • 不要使用boost:: smart 指针或std::auto_ptr除非在特殊情况下，如果必须，可以阅读。
  • 嘿，我没问过哪一个用！
    啊，但你真的想，承认它。
  • 那我什么时候应该使用常规指针呢？
    主要是代码中没有内存所有权。这通常是在从其他地方获取指针的函数中，并且不分配，解除分配或存储比其执行更长的指针的副本。

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

小型介绍可在页面上找到Smart Pointers - 什么，为什么，哪个？ 。

其中一个简单的智能指针类型是std::auto_ptr （C ++ 标准的第 20.4.5 节），它允许在超出范围时自动释放内存，并且在抛出异常时比简单指针使用更强大，尽管更少灵活。

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

题目在David Vandevoorde，Nicolai M. Josuttis ，第 20 章，智能指针的书“C ++ 模板：完整指南” 中有详细介绍。一些主题涉及：