c++ - 智能指针面试 - 智能指针的好处




什么是智能指针,我应该什么时候使用它? (10)

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


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


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

在计算机科学中,智能指针是一种抽象数据类型,可以在提供其他功能(如自动垃圾收集或边界检查)的同时模拟指针。 这些附加功能旨在减少由于滥用指针而导致的错误,同时保持效率。 为了内存管理的目的,智能指针通常会跟踪指向它们的对象。 指针的滥用是bug的主要来源:必须由使用指针编写的程序执行的常量分配,解除分配和引用使得很可能发生一些内存泄漏。 智能指针通过自动进行资源释放来防止内存泄漏:当指向对象的指针(或指针系列中的最后一个指针)被销毁时,例如因为它超​​出了作用域,指向的对象也被销毁。


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

它对于:

  • 必须用新分配的对象,但您希望与该堆栈中的某些对象具有相同的生命周期。 如果对象被分配给智能指针,那么当程序退出该功能/块时,它们将被删除。

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

在下列情况下您可能不想使用智能指针:

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

也可以看看:


下面是现代C ++这些日子的简单答案:

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

大多数智能指针为你处理指针对象。 这非常方便,因为您不必考虑手动处理对象。

最常用的智能指针是std::tr1::shared_ptr (或boost::shared_ptr ),并且不常用的是std::auto_ptr 。 我建议定期使用shared_ptr

shared_ptr功能非常强大,可以处理各种各样的处置场景,包括需要“跨DLL边界传递”对象的情况(如果在代码和DLL之间使用不同的libc则是常见的恶梦案例)。


我想补充一点,上面的问题,智能指针std :: shared_ptr没有下标运算符,并且不支持ponter算术,我们可以使用get()来获得一个内置的指针。


智能指针是一个包装“裸”(或“裸”)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_ptrstd::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_ptrstd::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_ptrstd::shared_ptrstd::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 ++中指定一个抽象的(或者实际上是任何)基类作为返回类型,第一个问题就是“你真正的意思是什么?”。 在boost指针容器库的文档中,有一篇关于C ++中惯用的面向对象编程(以及它如何与其他语言不同)的良好讨论(进一步参考)。 总之,在C ++中你必须考虑所有权。 哪些智能指针可以帮助你,但不是唯一的解决方案,或者总是一个完整的解决方案(它们不会给你多态拷贝),并不总是你想在你的界面中公开的解决方案(并且函数返回听起来很糟糕很像一个界面)。 例如,返回参考可能就足够了。 但是,在所有这些情况下(智能指针,指针容器或简单地返回引用),您已将从一个更改为某种形式的引用 。 如果你真的需要复制,你可能需要添加更多的样板“成语”,或者超越C ++中的惯用(或其他)OOP,使用类似Adobe PolyBoost.TypeErasure等库的更一般的多态。


设T是本教程中的一个类C ++中的指针可以分为3种类型:

1) 原始指针

T a;  
T * _ptr = &a; 

他们拥有一个内存地址到内存中的一个位置。 谨慎使用,因为程序变得复杂难以追踪。

使用常量数据或地址的指针{向后读取}

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

指向一个常量的数据类型T的指针。 这意味着您不能使用指针更改数据类型。 即*ptr1 = 19 ; 不管用。 但是你可以移动指针。 即ptr1++ , ptr1-- ; 等将工作。 向后读:指向类型T的指针,它是const

  T * const ptr2 ;

一个指向数据类型T的const指针。 意思是你不能移动指针,但你可以改变指针指向的值。 即*ptr2 = 19将工作,但ptr2++ ; ptr2-- ptr2++ ; ptr2--等不起作用。 向后读:const指针指向类型T

const T * const ptr3 ; 

指向常量数据类型T的const指针。 这意味着您不能移动指针,也不能将数据类型指针更改为指针。 即。 ptr3-- ; ptr3++ ; *ptr3 = 19; 不管用

3) 智能指针 :{ #include <memory> }

共享指针

  T a ; 
     //shared_ptr<T> shptr(new T) ; not recommended but works 
     shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe

     std::cout << shptr.use_count() ; // 1 //  gives the number of " 
things " pointing to it. 
     T * temp = shptr.get(); // gives a pointer to object

     // shared_pointer used like a regular pointer to call member functions
      shptr->memFn();
     (*shptr).memFn(); 

    //
     shptr.reset() ; // frees the object pointed to be the ptr 
     shptr = nullptr ; // frees the object 
     shptr = make_shared<T>() ; // frees the original object and points to new object

使用引用计数来实现,以跟踪有多少“东西”指向指针指向的对象。 当这个计数变为0时,该对象被自动删除,即当指向该对象的所有share_ptr超出范围时被删除。 这消除了必须删除使用新分配的对象的麻烦。

弱指针:帮助处理使用共享指针时产生的循环引用如果有两个对象由两个共享指针指向,并且有一个内部共享指针指向彼此共享指针,则会有循环引用,并且该对象不会当共享指针超出范围时被删除。 要解决这个问题,请将内部成员从shared_ptr更改为weak_ptr。 注意:要访问由弱指针指向的元素,使用lock(),这将返回一个weak_ptr。

T a ; 
shared_ptr<T> shr = make_shared<T>() ; 
weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr 
wk.lock()->memFn() ; // use lock to get a shared_ptr 
//   ^^^ Can lead to exception if the shared ptr has gone out of scope
if(!wk.expired()) wk.lock()->memFn() ;
// Check if shared ptr has gone out of scope before access

请参阅: std :: weak_ptr何时有用?

独特的指针:独有的轻量级智能指针。 当指针指向唯一对象而不共享指针之间的对象时使用。

unique_ptr<T> uptr(new T);
uptr->memFn(); 

//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr
uptr.reset() ; // deletes the object pointed to by uptr 

要更改唯一ptr指向的对象,请使用移动语义

unique_ptr<T> uptr1(new T);
unique_ptr<T> uptr2(new T);
uptr2 = std::move(uptr1); 
// object pointed by uptr2 is deleted and 
// object pointed by uptr1 is pointed to by uptr2
// uptr1 becomes null 

引用:它们本质上可以是const指针,即一个const指针,不能用更好的语法移动。

请参阅: C ++中的指针变量和引用变量之间的区别是什么?

r-value reference : reference to a temporary object   
l-value reference : reference to an object whose address can be obtained
const reference : reference to a data type which is const and cannot be modified 

参考: https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ : https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ感谢安德烈指出这个问题。





c++-faq