在现代的C++中（包括C++11及其之后的版本），下面是一个简单的答案：\n\n- \"什么是智能指针？\" 它是一种类型，其值可以像指针一样使用，而且还提供了自动内存管理的附加功能：当智能指针不再使用时，它指向的内存将被释放（另请参见维基百科上更详细的定义）。\n- \"何时使用智能指针？\" 在涉及跟踪内存所有权、分配或释放内存的代码中，智能指针通常可以省去显式执行这些操作的需要。\n- \"但在这些情况下应该使用哪种智能指针？\"\n\n- 使用std::unique_ptr，当您希望对象的生存期只与一个拥有引用它的引用相等时。例如，将其用于指向在进入某个范围时分配的内存并在退出该范围时释放的指针。\n- 当您确实希望从多个位置引用对象，并且不希望对象在这些引用自身被释放之前被释放时，使用std::shared_ptr。\n- 当您确实希望从多个位置引用对象，并且忽略并释放其中某些引用（因此在尝试解除引用时会发现对象已经不存在）时，请使用std::weak_ptr。\n- C++26中提出了将危险指针添加到语言中的提案，但目前还没有实现。\n- 不要在不必要的情况下使用boost::智能指针或std::auto_ptr，除非您必须在特殊情况下使用智能指针，请阅读相关文档了解详情。\n\n- \"嘿，我并没有问应该使用哪个！\" 但你确实想知道，不要否认吧。\n- \"那我什么时候应该使用普通指针？\" 大多数情况下是在对内存所有权毫不知情的代码中，这通常是在从其他地方获取指针的函数中，不分配也不释放，也不存储超出它们的执行期的指针副本。

更新

这个答案比较老，所以描述的是当时“好”的东西，即Boost库提供的智能指针。自从C++11以来，标准库提供了足够的智能指针类型，因此，您应该更倾向于使用 std::unique_ptr，std::shared_ptr 和 std::weak_ptr。

还有一个是 std::auto_ptr。它非常像作用域指针，但它还有“特殊”的危险能力可以被复制-这也意外地转移了所有权。
C++11中已经弃用，C++17中已被移除，因此您不应该使用它。

std::auto_ptr p1 (new MyObject());
std::auto_ptr 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 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 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 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 other;
};
std::shared_ptr p1 (new Owner());
std::shared_ptr 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 的弱（不计数的）引用。