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


当前回答

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

其他回答

智能指针是一种类似指针的对象,但它还提供了对构造、销毁、复制、移动和取消引用的控制。

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

例如,Boost提供了以下智能指针实现:

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_ptr表示共享所有权。std::auto_ptr在C++03中存在,但现在已弃用。

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

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

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

更新

这个答案相当陈旧,因此描述了当时的“好”,这是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实例。这可以防止指针被多次删除(错误地)。但是,您可以将对它的引用传递给您调用的其他函数。

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

更复杂的智能指针策略涉及对指针进行引用计数。这允许复制指针。当对象的最后一个“引用”被破坏时,该对象将被删除。此策略由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的弱(未计数)引用。

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

以下是类似答案的链接: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);