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

更新

这个答案相当陈旧，因此描述了当时“好”的东西，即 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 的弱（未计数）引用。

---

这是现代 C++（C++11 及更高版本）的一个简单答案：

“什么是智能指针？”它是一种类型，其值可以像指针一样使用，但它提供了自动内存管理的附加功能：当智能指针不再使用时，它指向的内存将被释放（另请参见 Wikipedia 上的更详细定义）。

“我什么时候应该用一个？”在涉及跟踪一块内存的所有权、分配或取消分配的代码中；智能指针通常使您无需明确地执行这些操作。

“但是在哪种情况下我应该使用哪个智能指针？”当您希望您的对象与对它的单个拥有引用一样存在时，请使用 std::unique_ptr。例如，将它用于指向内存的指针，该指针在进入某个范围时被分配并在退出范围时被取消分配。当您确实想从多个位置引用您的对象时使用 std::shared_ptr - 并且不希望在所有这些引用本身都消失之前释放您的对象。当您确实想从多个位置引用您的对象时，请使用 std::weak_ptr - 对于那些可以忽略和取消分配的引用（因此当您尝试取消引用时，他们只会注意到该对象已消失）。不要使用 boost:: 智能指针或 std::auto_ptr 除非在特殊情况下，如果你必须阅读的话。

当您希望您的对象与对它的单个拥有引用一样存在时，请使用 std::unique_ptr。例如，将它用于指向内存的指针，该指针在进入某个范围时被分配并在退出范围时被取消分配。

当您确实想从多个位置引用您的对象时使用 std::shared_ptr - 并且不希望在所有这些引用本身都消失之前释放您的对象。

当您确实想从多个位置引用您的对象时，请使用 std::weak_ptr - 对于那些可以忽略和取消分配的引用（因此当您尝试取消引用时，他们只会注意到该对象已消失）。

不要使用 boost:: 智能指针或 std::auto_ptr 除非在特殊情况下，如果你必须阅读的话。

“喂，我没问用哪一个！”啊，但你真的很想，承认吧。

“那么我什么时候应该使用常规指针呢？”主要是在忽略内存所有权的代码中。这通常是在从其他地方获取指针并且不分配或取消分配的函数中，并且不存储指针的副本，该副本的执行时间超过了它们的执行时间。

---

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 章“智能指针”对此主题进行了深入介绍。涵盖的一些主题：

防止异常

持有者，（注意，std::auto_ptr 是这种类型的智能指针的实现）

资源获取就是初始化（这在 C++ 中经常用于异常安全的资源管理）

持有人限制

引用计数

并发计数器访问

销毁和释放

---

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

---

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

它适用于：

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

类的数据成员，因此当对象被删除时，所有拥有的数据也会被删除，而在析构函数中没有任何特殊代码（您需要确保析构函数是虚拟的，这几乎总是一件好事） .

在以下情况下，您可能不想使用智能指针：

...指针实际上不应该拥有数据...即，当您只是使用数据时，但您希望它在您引用它的函数中存在。

...智能指针本身不会在某个时候被破坏。您不希望它位于永远不会被破坏的内存中（例如在动态分配但不会被显式删除的对象中）。

...两个智能指针可能指向相同的数据。 （然而，还有更智能的指针可以处理这个问题……这就是所谓的引用计数。）

也可以看看：

垃圾收集。

这个关于数据所有权的堆栈溢出问题

---

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

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

例如，Boost 提供以下智能指针实现：

shared_ptr 是一个指向 T 的指针，它使用引用计数来确定何时不再需要该对象。

scoped_ptr 是超出范围时自动删除的指针。没有分配是可能的。

intrusive_ptr 是另一个引用计数指针。它提供了比 shared_ptr 更好的性能，但需要类型 T 提供自己的引用计数机制。

weak_ptr 是一个弱指针，与 shared_ptr 一起工作以避免循环引用。

shared_array 类似于 shared_ptr，但用于 T 的数组。

scoped_array 类似于 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_ptr），以及不太常用的 std::auto_ptr。我建议经常使用 shared_ptr。

shared_ptr 用途广泛，可处理多种处置方案，包括对象需要“跨 DLL 边界传递”的情况（如果在您的代码和 DLL 之间使用不同的 libc，这是常见的噩梦情况）。

---

这是类似答案的链接：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);

---

让 T 成为本教程中的一个类 C++ 中的指针可以分为 3 种类型：

1）原始指针：

T a;  
T * _ptr = &a; 

它们将内存地址保存到内存中的某个位置。谨慎使用，因为程序变得复杂难以跟踪。

带有 const 数据或地址的指针 { 向后读取 }

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

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

  T * const ptr2 ;

指向数据类型 T 的 const 指针。这意味着您不能移动指针，但可以更改指针指向的值。即 *ptr2 = 19 将起作用，但 ptr2++ ; ptr2-- 等将不起作用。向后阅读：指向类型 T 的 const 指针

const T * const ptr3 ; 

指向 const 数据类型 T 的 const 指针。这意味着您不能移动指针，也不能将数据类型指针更改为指针。 IE 。 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 超出范围时，objected 被删除。这消除了必须删除使用 new 分配的对象的麻烦。

弱指针：帮助处理使用共享指针时出现的循环引用当共享指针超出范围时被删除。要解决此问题，请将内部成员从 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

请参阅：When is std::weak_ptr useful?

唯一指针：具有专有所有权的轻量级智能指针。当指针指向唯一对象而不在指针之间共享对象时使用。

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 指针，不能用更好的语法移动。

请参阅：What are the differences between a pointer variable and a reference variable in 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 感谢 Andre 指出这个问题。

---

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

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

---

智能指针是一个类，是普通指针的包装器。与普通指针不同，智能点的生命周期基于引用计数（分配智能指针对象的次数）。因此，每当将一个智能指针分配给另一个智能指针时，内部引用计数就会加上。并且每当对象超出范围时，引用计数减负。

自动指针虽然看起来很相似，但与智能指针完全不同。这是一个方便的类，当自动指针对象超出变量范围时，它会释放资源。在某种程度上，它使指针（指向动态分配的内存）的工作方式类似于堆栈变量（在编译时静态分配）。

---

什么是智能指针。

长版，原则上：

https://web.stanford.edu/class/archive/cs/cs106l/cs106l.1192/lectures/lecture15/15_RAII.pdf

现代 C++ 习语：

RAII: Resource Acquisition Is Initialization.

● When you initialize an object, it should already have 
  acquired any resources it needs (in the constructor).


● When an object goes out of scope, it should release every 
  resource it is using (using the destructor).

关键：

● There should never be a half-ready or half-dead object.
● When an object is created, it should be in a ready state.
● When an object goes out of scope, it should release its resources. 
● The user shouldn’t have to do anything more. 

原始指针违反 RAII：当指针超出范围时需要用户手动删除。

RAII 解决方案是：

Have a smart pointer class:
● Allocates the memory when initialized
● Frees the memory when destructor is called
● Allows access to underlying pointer

对于需要复制和共享的智能指针，请使用 shared_ptr：

● use another memory to store Reference counting and shared.
● increment when copy, decrement when destructor.
● delete memory when Reference counting is 0. 
  also delete memory that store Reference counting.

对于不拥有原始指针的智能指针，请使用weak_ptr：

● not change Reference counting.

shared_ptr 用法：

correct way:
std::shared_ptr<T> t1 = std::make_shared<T>(TArgs);
std::shared_ptr<T> t2 = std::shared_ptr<T>(new T(Targs));

wrong way:
T* pt = new T(TArgs); // never exposure the raw pointer
shared_ptr<T> t1 = shared_ptr<T>(pt);
shared_ptr<T> t2 = shared_ptr<T>(pt);

始终避免使用原始指针。

对于必须使用原始指针的场景：

https://stackoverflow.com/a/19432062/2482283

对于非 nullptr 的原始指针，请改用引用。

not use T*
use T&  

对于可能为 nullptr 的可选引用，请使用原始指针，这意味着：

T* pt; is optional reference and maybe nullptr.
Not own the raw pointer, 
Raw pointer is managed by some one else.
I only know that the caller is sure it is not released now.

---

智能指针是那些您不必担心内存解除分配、资源共享和传输的指针。

您可以很好地使用这些指针，就像在 Java 中进行任何分配一样。在 java Garbage Collector 中可以做到这一点，而在 Smart Pointers 中，这个技巧是由析构函数完成的。

---

现有答案很好，但没有涵盖当智能指针不是您要解决的问题的（完整）答案时该怎么做。

除其他事项外（在其他答案中有很好的解释），使用智能指针是 How do we use a abstract class as a function return type? 的一种可能解决方案，它已被标记为该问题的副本。但是，如果想在 C++ 中将抽象（或实际上任何）基类指定为返回类型，第一个要问的问题是“你真正的意思是什么？”。 boost pointer container library 的文档中对 C++ 中惯用的面向对象编程（以及这与其他语言有何不同）进行了很好的讨论（有更多参考资料）。总之，在 C++ 中，您必须考虑所有权。哪些智能指针可以帮助您，但不是唯一的解决方案，或者始终是完整的解决方案（它们不会为您提供多态副本）并且并不总是您想要在界面中公开的解决方案（并且函数返回听起来很糟糕很像一个界面）。例如，返回一个引用可能就足够了。但是在所有这些情况下（智能指针、指针容器或简单地返回引用），您已经将返回从 value 更改为某种形式的 reference。如果您真的需要副本，您可能需要添加更多样板“习语”或超越 C++ 中的惯用（或其他）OOP 到使用 Adobe Poly 或 Boost.TypeErasure 等库的更通用的多态性。

---