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

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

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

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

例如，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中存在，但现在已弃用。

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

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

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

在计算机科学中，智能指针是一种抽象数据类型模拟指针，同时提供其他功能，如自动垃圾收集或边界检查。这些附加功能旨在减少因误用指针，同时保持效率。智能指针通常跟踪指向它们的对象内存管理的目的。这个指针的误用是一个主要原因错误：恒定分配，释放和引用由编写的程序执行使用指针很可能会发生一些内存泄漏。智能指针试图阻止内存通过制造资源泄漏自动解除分配：当指向对象的指针（或一系列指针）被破坏例如，因为它超出了范围，指向的对象也被破坏。

更新

这个答案相当陈旧，因此描述了当时的“好”，这是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在大多数情况下都是足够的，但它们也有自己的一些小特点。