智能指针是那些你不必担心内存取消分配、资源共享和传输的地方。

您可以很好地使用这些指针，其方式与Java中的任何分配方式类似。在java垃圾收集器中完成了这一任务，而在智能指针中，这一任务由Destructor完成。

更新

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

更新：

对于过去使用的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 感谢安德烈指出了这个问题。

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