什么是智能指针，我应该什么时候使用它？
什么是智能指针，我应该什么时候使用它？
智能指针是一个包装“裸”（或“裸”）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()
{
{
boost::scoped_ptr<MyObject> ptr(new MyObject());
ptr->DoSomethingUseful();
} // boost::scopted_ptr goes out of scope --
// the MyObject is automatically destroyed.
// ptr->Oops(); // Compile error: "ptr" not defined
// since it is no longer in scope.
}
请注意，不能复制scoped_ptr实例。 这可以防止多次删除指针（不正确）。 但是，您可以将引用传递给您调用的其他函数。
当您想要将对象的生命周期与特定的代码块关联起来时，或者将其作为成员数据嵌入到另一个对象中时，该对象的生命周期是有用的。 该对象一直存在，直到包含代码块被退出，或者直到包含对象本身被销毁。
更复杂的智能指针策略涉及对指针进行引用计数。 这确实允许指针被复制。 当对象的最后一个“引用”被销毁时，对象被删除。 这个策略由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 {
boost::shared_ptr<Owner> other;
};
boost::shared_ptr<Owner> p1 (new Owner());
boost::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的弱（不计数）引用。
UPDATE
这个答案相当古老，因此描述了当时的“好”，这是由Boost库提供的智能指针。 自C ++ 11以来，标准库提供了足够的智能指针类型，因此您应该倾向于使用std::unique_ptr ， std::shared_ptr和std::weak_ptr 。
还有std::auto_ptr 。 它非常像一个范围指针，除了它还具有被复制的“特殊”危险能力 - 这也意外地转移了所有权！ 它在最新的标准中被弃用，所以你不应该使用它。 改为使用std::unique_ptr 。
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 ++这些日子的简单答案：
它是一种可以像指针一样使用的值，但提供了自动内存管理的附加功能：当指针不再使用时，它指向的内存被释放（另请参阅维基百科上更详细的定义）。
在代码中涉及跟踪一块内存的所有权，分配或取消分配; 智能指针通常可以帮助您明确地完成这些任务。
std::unique_ptr 。 例如，将它用于指向内存的指针，该内存在进入某个范围时得到分配，并在退出范围时取消分配。 std::shared_ptr - 并且不希望它被解除分配，直到所有这些引用本身消失。 std::weak_ptr - 对于那些可以忽略和释放的引用（所以他们只会注意到当你尝试解引用时对象已经消失）。 boost:: smart指针或std::auto_ptr除非在特殊情况下，如果必须的话，您可以阅读它们。 啊，但你真的想承认这一点。
主要是在对内存所有权不知情的代码中。 这通常是在从其他位置获得指针的函数中，并且不分配，取消分配或存储超出其执行的指针的副本。
智能指针是一种类似指针的类型，具有一些附加功能，例如自动内存释放，引用计数等。
小介绍可在页面智能指针 - 什么，为什么，哪一个？
其中一个简单的智能指针类型是std::auto_ptr （C ++标准的第20.4.5章），它允许在超出范围时自动释放内存，并且在抛出异常时比使用简单指针更加健壮，尽管更少灵活。
另一种方便的类型是boost::shared_ptr ，它实现引用计数并在没有引用对象时自动释放内存。 这有助于避免内存泄漏，并且易于使用来实现RAII。
David Vandevoorde，Nicolai M. Josuttis在第20章第20章“C ++模板：完全指南”一书中深入讨论了主题。智能指针。 一些主题包括：