在现代C++（C++11及以上版本）中，这里有一个简单的答案：

• “什么是智能指针？”
  它是一种类型，其值可像指针一样使用，但提供了自动内存管理的附加功能：当智能指针不再使用时，其指向的内存会被释放（另请参阅维基百科上的更详细定义）。
• “何时应该使用智能指针？”
  在涉及追踪内存所有权、分配或解除分配的代码中，智能指针通常可以帮助你避免必须明确执行这些操作的需要。
• “但我应该在哪些情况下使用哪些类型的智能指针？”
  • 当您希望对象生存的时间与单个拥有引用它的引用存在时间相同时，使用 std::unique_ptr 。例如，对于在进入某个作用域时分配并在退出作用域时释放的内存的指针。
  • 当您确实希望从多个位置引用对象 - 并且不希望在这些引用自身消失之前使对象被释放时，使用 std::shared_ptr 。
  • 当您确实希望从多个位置引用对象，并且可以忽略和释放其中的引用（因此只有在尝试取消引用时才会注意到对象已经不存在）时，使用 std::weak_ptr 。
  • 有一个建议将hazard pointers添加到C++26中，但目前还没有。
  • 除非在必要的特殊情况下，不要使用boost::智能指针或std::auto_ptr，这些情况您可以查阅资料了解。
• “嘿，我没有问你应该使用哪个！”
  啊，但你真的想问，承认吧。
• “那我什么时候应该使用常规指针呢？”
  大多数情况下，在代码中不关心内存所有权的地方。这通常是在从其他地方获取指针的函数中，既不分配也不释放，也不存储超过它们的执行的指针的副本。

更新

此回答比较陈旧，所描述的是过去“好”的内容，即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的弱（未计数）引用。