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


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


1429
2017-09-20 00:09


起源


看看这个问题:<br> 聪明的指针:或谁拥有你的宝贝 - Martin York
请注意,Visual Studio 2005中std :: auto_ptr的实现严重受损。点击http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=98871点击 http://connect.microsoft.com/VisualStudio/feedback/ViewFeedback.aspx?FeedbackID=101842 请改用boost。 - Richard
关于这个问题的两篇优秀文章: - 智能指针 - 什么,为什么,哪个?  - 本周大师#25 - Lazer
这是Alexandrescu的(免费)章节,介绍了创建不同风格的智能指针的细节: informit.com/articles/article.aspx?p=31529  在他的实现中,他使用模板参数作为“策略”来指定他想要的属性(例如,引用计数),而标准库使用单独的类。请注意,在rvalue引用可用于使std :: unique_ptr成为可能之前,他也在写作。 - metal


答案:


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

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

使用原始指针,程序员必须在不再有用时显式地销毁该对象。

// 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 定义a的弱(不计数)引用 shared_ptr


UPDATE

这个答案相当陈旧,因此描述了当时的“好”,这是Boost库提供的智能指针。从C ++ 11开始,标准库提供了足够的智能指针类型,所以你应该倾向于使用 std::unique_ptrstd::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.

1641
2017-09-20 00:48



你的意思是 std::auto_ptr<MyObject> p1 (new MyObject()); 代替 std::auto_ptr<MyObject> p1 (new Owner());? - Mateen Ulhaq
很棒的答案。如果为c ++ 11更新它会很好。我找到了这个答案,寻找有关新11标准的信息,如果未来的访问者能够找到更新的信息,那将是很好的。我知道auto_ptr已被弃用。我相信shated_ptr和weak_ptr如上所述存在,我认为scoped_ptr现在是标准中的unique_ptr。如果这是真的,请回答这个答案吗? - SaulBack
要说创建悬挂引用的可能性是引用计数指针的一个缺点,绝对是疯了。可能的悬挂参考是一个缺点 任何C ++指针。事实上,它是 正是这个缺点 智能指针的意图 缓和。 - anthropomorphic
如果你声明一个指向智能指针的指针(就像在示例中所做的那样),你会故意放弃智能指针的所有好处。这不是缺点或设计缺陷,它是可以想象的最愚蠢的用法。 - anthropomorphic
很好的答案。如果为C ++ 14更新它会很好。嘿,whaddaya知道,有人对C ++ 11做了同样的评论,三年多前...... :-( - einpoklum


这是现代C ++的简单答案:

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

170
2018-05-09 19:06



值得注意的是,虽然智能(拥有)指针有助于正确的内存管理,但原始(非拥有)指针仍然可用于数据结构中的其他组织目的。 Herb Sutter在2016年CppCon上对此事做了精彩演讲,您可以在YouTube上看到: C ++中的泄漏自由......默认情况下。 - wiktor.wandachowicz
我在网上找到的第一个非常简单易懂的答案!谢谢! - Bernd


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

小型介绍可在页面上找到 智能指针 - 什么,为什么,哪个?

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

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

主题在书中深入讨论 “C ++模板:完整指南”,作者:David Vandevoorde,Nicolai M. Josuttis,第20章。智能指针。 涉及的一些主题:


97
2017-09-20 00:32



+1是这个列表中唯一的答案(当前18个活跃的答案),甚至提到 RAII。 - WhozCraig


Chris,Sergdev和Llyod提供的定义是正确的。我更喜欢更简单的定义,只是为了让我的生活变得简单: 智能指针只是一个重载的类 ->* 运营商。这意味着你的对象在语义上看起来像一个指针,但你可以让它做更酷的事情,包括引用计数,自动销毁等。 shared_ptr 和 auto_ptr 在大多数情况下是足够的,但伴随着他们自己的一套小特质。


33
2017-09-20 01:53





智能指针就像常规(类型)指针,如“char *”,除非指针本身超出范围,否则它指向的内容也会被删除。您可以像使用常规指针一样使用“ - >”,但如果您需要实际的数据指针则不能。为此,您可以使用“&* ptr”。

它对以下内容很有用:

  • 必须使用new分配的对象,但是您希望与该堆栈上的内容具有相同的生命周期。如果将对象分配给智能指针,则在程序退出该功能/块时将删除它们。

  • 类的数据成员,以便在删除对象时删除所有拥有的数据,在析构函数中没有任何特殊代码(您需要确保析构函数是虚拟的,这几乎总是一件好事) 。

你可以  想要在以下情况下使用智能指针:

  • ...指针实际上不应该拥有数据...即,当您只是使用数据时,但是您希望它能够在您引用它的函数中存活。
  • ......智能指针本身不会在某些时候被破坏。您不希望它位于永远不会被破坏的内存中(例如在动态分配但不会被显式删除的对象中)。
  • ......两个智能指针可能指向相同的数据。 (然而,有更聪明的指针可以处理......被称为 引用计数。)

也可以看看:


26
2017-09-20 00:13





大多数类型的智能指针都会为您处理指针对象的处理。它非常方便,因为您不必再​​考虑手动处理对象了。

最常用的智能指针是 std::tr1::shared_ptr (要么 boost::shared_ptr),不太常见, std::auto_ptr。我建议经常使用 shared_ptr

shared_ptr 是非常通用的,处理各种各样的处理场景,包括对象需要“跨越DLL边界”的情况(如果不同,常见的恶梦案例) libc在您的代码和DLL之间使用s)。


14
2017-09-20 00:14





智能指针是一个像指针一样的对象,但另外还提供对构造,销毁,复制,移动和解除引用的控制。

人们可以实现自己的智能指针,但许多库也提供智能指针实现,每个实现都有不同的优点和缺点。

例如, 促进 提供以下智能指针实现:

  • shared_ptr<T> 是一个指针 T 使用引用计数来确定何时不再需要该对象。
  • scoped_ptr<T> 超出范围时自动删除的指针。无法进行任务。
  • intrusive_ptr<T>是另一个引用计数指针。它提供了比...更好的性能 shared_ptr,但需要类型 T 提供自己的参考计数机制。
  • weak_ptr<T> 是一个弱指针,与...一起工作 shared_ptr 避免循环引用。
  • shared_array<T> 就好像 shared_ptr,但对于数组 T
  • scoped_array<T> 就好像 scoped_ptr,但对于数组 T

这些只是每个的一个线性描述,可以根据需要使用,进一步的细节和示例可以看看Boost的文档。

此外,C ++标准库提供了三个智能指针; std::unique_ptr 独特的所有权, std::shared_ptr 共享所有权和 std::weak_ptrstd::auto_ptr 存在于C ++ 03中但现已弃用。


14
2018-03-12 09:51



请解释原因 scoped_ptr 不像是在当地宣布的 const unique_ptr  - 退出范围时也会被删除。 - einpoklum


以下是类似答案的链接: http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

智能指针是一种对象,其行为,外观和感觉类似于普通指针,但提供更多功能。在C ++中,智能指针实现为封装指针和覆盖标准指针运算符的模板类。与常规指针相比,它们具有许多优点。保证将它们初始化为空指针或指向堆对象的指针。检查通过空指针的间接方向。不需要删除。当指向它们的最后一个指针消失时,对象会自动释放。这些智能指针的一个重要问题是,与常规指针不同,它们不尊重继承。智能指针对多态代码没有吸引力。下面给出了智能指针实现的示例。

例: 

template <class X>
class smart_pointer
{
          public:
               smart_pointer();                          // makes a null pointer
               smart_pointer(const X& x)            // makes pointer to copy of x

               X& operator *( );
               const X& operator*( ) const;
               X* operator->() const;

               smart_pointer(const smart_pointer <X> &);
               const smart_pointer <X> & operator =(const smart_pointer<X>&);
               ~smart_pointer();
          private:
               //...
};

该类实现了一个指向X类型对象的智能指针。该对象本身位于堆上。以下是如何使用它:

smart_pointer <employee> p= employee("Harris",1333);

像其他重载运算符一样,p的行为类似于常规指针,

cout<<*p;
p->raise_salary(0.5);

9
2018-03-07 09:03





http://en.wikipedia.org/wiki/Smart_pointer

在计算机科学中,一个智能指针   是一种抽象数据类型   在提供时模拟指针   附加功能,如自动   垃圾收集或边界检查。   这些附加功能是有意的   减少误用造成的错误   指针同时保持效率。   智能指针通常会跟踪   指向它们的对象   内存管理的目的。该   滥用指针是一个主要来源   错误:不断分配,   必须释放和引用   由一个程序执行   使用指针很有可能   会发生一些内存泄漏。   智能指针试图阻止内存   通过制作资源泄漏   释放自动:当时   指向对象的指针(或指向对象的指针)   因为,系列指针被破坏了   例如,因为它超出了范围,   尖头的物体也被毁坏了。


8
2017-09-20 00:12