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

它适用于：

对象必须分配新的，但您希望与堆栈中的对象具有相同的生存期。如果对象被分配给智能指针，那么当程序退出该函数/块时，它们将被删除。类的数据成员，因此当对象被删除时，所有拥有的数据也会被删除，而析构函数中没有任何特殊代码（您需要确保析构函数是虚拟的，这几乎总是一件好事）。

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

…指针实际上不应该拥有数据。。。即，当您只是在使用数据，但希望它在引用它的函数中生存时。…智能指针本身不会在某个时刻被破坏。您不希望它位于永远不会被破坏的内存中（例如动态分配但不会显式删除的对象中）。…两个智能指针可能指向相同的数据。（然而，还有更聪明的指针可以处理这一点……这就是所谓的引用计数。）

另请参见：

垃圾收集。关于数据所有权的堆栈溢出问题

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

它适用于：

对象必须分配新的，但您希望与堆栈中的对象具有相同的生存期。如果对象被分配给智能指针，那么当程序退出该函数/块时，它们将被删除。类的数据成员，因此当对象被删除时，所有拥有的数据也会被删除，而析构函数中没有任何特殊代码（您需要确保析构函数是虚拟的，这几乎总是一件好事）。

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

…指针实际上不应该拥有数据。。。即，当您只是在使用数据，但希望它在引用它的函数中生存时。…智能指针本身不会在某个时刻被破坏。您不希望它位于永远不会被破坏的内存中（例如动态分配但不会显式删除的对象中）。…两个智能指针可能指向相同的数据。（然而，还有更聪明的指针可以处理这一点……这就是所谓的引用计数。）

另请参见：

垃圾收集。关于数据所有权的堆栈溢出问题

现有的答案很好，但不包括当智能指针不是您试图解决的问题的（完整）答案时该做什么。

除了其他事情（在其他答案中解释得很好）之外，使用智能指针是如何将抽象类用作函数返回类型的一个可能的解决方案？该问题被标记为该问题的副本。然而，如果想在C++中指定抽象（或实际上任何）基类作为返回类型，首先要问的问题是“你真正的意思是什么？”。boost指针容器库的文档中对C++中惯用的面向对象编程（以及这与其他语言的区别）进行了很好的讨论（并提供了进一步的参考）。总之，在C++中，您必须考虑所有权。哪些智能指针可以帮助您，但不是唯一的解决方案，或者总是一个完整的解决方案（它们不会为您提供多态副本），也不总是您希望在接口中公开的解决方案。例如，返回引用就足够了。但是在所有这些情况下（智能指针、指针容器或简单地返回引用），您已经将返回从值更改为某种形式的引用。如果你真的需要复制，你可能需要添加更多的样板“习惯用法”，或者使用Adobe Poly或Boost.TypeErasure等库从C++中的惯用（或其他）OOP过渡到更通用的多态性。

更新：

对于过去使用的C++类型，这个答案已经过时了。std:：auto_ptr在新标准中被弃用并删除。应该使用std：：shared_ptr而不是boost:：shared_pt，这是标准的一部分。

与智能指针原理背后的概念的联系仍然是最相关的。

现代C++具有以下智能指针类型，不需要boost智能指针：

std:：shared_ptr标准：：weak_ptr标准：：unique_ptr

答案中还提到了该书的第二版：《C++模板：完整指南第二版》，作者：David Vandvoorde Nicolai、M.Josuttis、Douglas Gregor

旧答案：

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

智能指针页面上有一个小介绍-什么，为什么，哪个？。

其中一种简单的智能指针类型是std:：auto_ptr（C++标准第20.4.5章），它允许在内存超出范围时自动释放内存，并且在抛出异常时比简单的指针用法更健壮，尽管灵活性较低。

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

David Vandvoorde、Nicolai M.Josuttis的《C++模板：完整指南》一书第20章对这一主题进行了深入探讨。智能指针。涉及的一些主题：

防止异常Holders，（注意，std:：auto_ptr是此类智能指针的实现）资源获取是初始化（这通常用于C++中的异常安全资源管理）持有人限制参考计数并发计数器访问销毁和处置

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

1） 原始指针：

T a;  
T * _ptr = &a; 

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

具有常量数据或地址的指针｛向后读取｝

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

指向作为常量的数据类型T的指针。这意味着不能使用指针更改数据类型。ie*ptr1＝19；不会起作用。但是你可以移动指针。即ptr1++、ptr1--；等等都会起作用。向后读取：指向类型T（常量）的指针

  T * const ptr2 ;

指向数据类型T的常量指针。这意味着不能移动指针，但可以更改指针指向的值。ie*ptr2＝19将工作，但ptr2++；ptr2等将不起作用。向后读取：指向T类型的常量指针

const T * const ptr3 ; 

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

请参见：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 

参考文献：它们本质上可以被认为是常量指针，即常量指针，不能用更好的语法移动。

参见：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 感谢安德烈指出了这个问题。

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