什么是智能指针，何时应使用？

什么是智能指针，何时应使用？

更新

这个答案很旧，因此描述了当时什么是“好”，这是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实例无法复制。这样可以防止多次（不正确）删除指针。但是，您可以将对其的引用传递给您调用的其他函数。

std::unique_ptr如果要将对象的生存期绑定到特定代码块，或者将其作为成员数据嵌入另一个对象的生存期，则s很有用。该对象将一直存在，直到退出包含代码的块，或者直到包含对象本身被销毁为止。

更复杂的智能指针策略涉及对指针进行引用计数。这确实允许复制指针。当该对象的最后一个“引用”被销毁时，该对象将被删除。此政策由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都定义了a weak_ptr来定义对a的弱引用（未计数）shared_ptr。

这是当今现代C ++（C ++ 11及更高版本）的一个简单答案：

• 什么是智能指针？
  这种类型的值可以像指针一样使用，但是提供了自动内存管理的附加功能：当不再使用智能指针时，它所指向的内存将被释放（另请参见Wikipedia上的更详细的定义）。
• 我什么时候应该使用？
  在涉及跟踪内存所有权，分配或取消分配的代码中；智能指针通常可以节省您显式执行这些操作的需要。
• 但是在那些情况下，我应该使用哪个智能指针？
  • 使用std::unique_ptr时，你不打算持有到同一对象的多个引用。例如，将其用作指向内存的指针，该内存在进入某些范围时被分配，而在退出范围时被取消分配。
  • 使用std::shared_ptr当你想从多个地方是指你的对象-并且不希望你的对象是去分配，直到所有这些提法本身就没了。
  • std::weak_ptr当您确实想从多个位置引用对象时，请使用-对于可以忽略和取消分配的引用（因此，当您尝试取消引用时，它们只会指出对象已消失）。
  • 请勿使用boost::智能指针，或者std::auto_ptr在特殊情况下（除非您必须阅读）可以使用。
• 嘿，我没问要用哪一个！
  啊，但是你真的想承认。
• 那么，什么时候应该使用常规指针呢？
  大多数情况下，代码会忽略内存所有权。这通常会出现在从其他地方获取指针，不分配也不取消分配，并且不存储指针的副本的函数中，这些指针的执行使它们的执行时间更长。

智能指针是一种类似指针的类型，具有一些其他功能，例如自动内存释放，引用计数等。

在智能指针-什么，为什么，哪个页面上提供了小型介绍。。

一种简单的智能指针类型std::auto_ptr（C ++标准的20.4.5章）允许在超出范围时自动释放内存，并且比引发异常时的简单指针使用更健壮，尽管灵活性较差。

另一种方便的类型是boost::shared_ptr实现引用计数并在没有剩余对对象的引用时自动分配内存。这有助于避免内存泄漏，并且易于使用来实现RAII。

David Vandevoorde的《 C ++模板：完整指南》一书在Nicolai M. Josuttis的第20章“智能指针”中进行了详细介绍。涵盖了一些主题：

• 防止异常
• 持有人，（请注意，std :: auto_ptr是此类智能指针的实现）
• 资源获取即初始化（在C ++中经常用于异常安全的资源管理）
• 持有人限制
• 参考计数
• 并发计数器访问
• 销毁和重新分配

Chris，Sergdev和Llyod提供的定义是正确的。不过，我更喜欢一个简单的定义，只是为了使我的生活更简单：智能指针只是一个重载-> and *运算符的类。这意味着您的对象在语义上看起来像一个指针，但是您可以使它做一些更酷的事情，包括引用计数，自动销毁等 shared_ptr，auto_ptr并且在大多数情况下就足够了，但是还带有它们自己的一组小特质。

智能指针就像常规的（类型化的）指针，如“ char *”一样，除了当指针本身超出范围时，它所指向的内容也会被删除。您可以像使用常规指针一样使用“->”来使用它，但是如果您需要一个实际的数据指针，则不需要。为此，您可以使用“＆* ptr”。

它对：

• 必须分配给new的对象，但您希望拥有与该堆栈上的对象相同的生存期。如果将对象分配给智能指针，则在程序退出该功能/块时将删除它们。

• 类的数据成员，以便在删除对象时也删除所有拥有的数据，而在析构函数中没有任何特殊代码（您将需要确保析构函数是虚拟的，这几乎总是一件好事） 。

你可能不希望使用智能指针时：

• ...指针实际上不应该拥有数据...，即，当您仅使用数据时，但是您希望它在引用它的函数中存活下来。
• ...智能指针本身不会在某个时候被破坏。您不希望它位于永不被破坏的内存中（例如，在动态分配但不会明确删除的对象中）。
• ...两个智能指针可能指向同一数据。（但是，还有更聪明的指针可以处理此问题……这称为引用计数。）

也可以看看：

• 垃圾收集。
• 有关数据所有权的此堆栈溢出问题

大多数类型的智能指针都会为您处理指向对象的处理。这非常方便，因为您不必再​​考虑手动处理对象。

最常用的智能指针是std::tr1::shared_ptr（或boost::shared_ptr），而不太常见的是std::auto_ptr。我建议定期使用shared_ptr。

shared_ptr具有多种用途，并且处理各种各样的情况，包括需要“跨越DLL边界传递对象”的情况（如果libc代码和DLL之间使用不同的s，则是常见的噩梦）。

智能指针是一个对象，其作用类似于指针，但还提供了对构造，破坏，复制，移动和取消引用的控制。

一个人可以实现自己的智能指针，但是许多库还提供了智能指针实现，每种实现都有其优缺点。

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

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

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

在计算机科学中，智能指针是一种抽象的数据类型，它在提供附加功能（例如自动垃圾收集或边界检查）的同时模拟指针。这些附加功能旨在减少因滥用指针而导致的错误，同时保持效率。智能指针通常会跟踪指向它们的对象，以进行内存管理。指针的滥用是错误的主要来源：必须由使用指针编写的程序执行常量分配，释放和引用，这很可能会发生一些内存泄漏。智能指针试图通过使资源自动分配来防止内存泄漏：当对象的指针（或一系列指针中的最后一个）被破坏时，

让T作为本教程的类C ++中的指针可以分为3种类型：

1）原始指针：

T a;  
T * _ptr = &a; 

它们将内存地址保存到内存中的某个位置。谨慎使用，因为程序变得复杂，难以跟踪。

具有const数据或地址的指针{向后读}

T a ; 
const T * ptr1 = &a ; 
T const * ptr1 = &a ;

指向作为常量的数据类型T的指针。意味着您不能使用指针更改数据类型。即*ptr1 = 19; 不管用。但是您可以移动指针。即ptr1++ , ptr1--; 等会工作。向后读：指向类型T的指针，它是const

  T * const ptr2 ;

指向数据类型T的const指针。意味着您不能移动指针，但是可以更改指针指向的值。即*ptr2 = 19可以工作，但ptr2++ ; ptr2--等将无法正常工作。向后读取：指向类型T的const指针

const T * const ptr3 ; 

指向const数据类型T的const指针。这意味着您既不能移动指针，也不能将数据类型指针更改为指针。即。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指向的对象，请使用move语义

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 

参考：本质上，它们可以作为const指针，即const指针，不能使用更好的语法移动。

请参阅：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 感谢Andre指出了这个问题。

智能指针是一个类，是普通指针的包装。与普通指针不同，智能点的生命周期基于参考计数（智能指针对象被分配多少次）。因此，每当将智能指针分配给另一个指针时，内部引用计数就会加上加号。每当对象超出范围时，引用计数就为负。

自动指针虽然看起来很相似，但与智能指针完全不同。这是一个方便的类，每当自动指针对象超出变量范围时，该类便会释放资源。在某种程度上，它使指针（指向动态分配的内存）的工作方式类似于堆栈变量（在编译时静态分配）。

智能指针是那些您不必担心内存分配，资源共享和传输的指针。

您可以很好地使用这些指针，就像在Java中进行任何分配一样。在Java垃圾收集器中，该技巧可以解决问题；而在智能指针中，该技巧是由析构函数完成的。

现有的答案很好，但没有涵盖当智能指针不是您要解决的问题的（完整）答案时的处理方法。

除其他外（在其他答案中也有很好的解释），使用智能指针是解决如何将抽象类用作函数返回类型的一种可能的解决方案？已被标记为该问题的重复项。但是，问是否试图将抽象（或实际上任何）基类指定为C ++中的返回类型的第一个问题是“您真正的意思是什么？”。在boost指针容器库的文档中对C ++中的惯用的面向对象编程进行了很好的讨论（以及进一步的参考）（以及与其他语言有何不同）。。总而言之，在C ++中，您必须考虑所有权。哪些智能指针可以为您提供帮助，但不是唯一的解决方案，也不总是一个完整的解决方案（它们不会给您多态副本），也不总是您想要在界面中公开的解决方案（函数返回听起来很糟糕）非常像一个界面）。例如，返回引用可能就足够了。但是在所有这些情况下（智能指针，指针容器或仅返回引用），您已将返回值从值更改为某种形式的引用。如果您确实需要复制，则可能需要添加更多样板“惯用语”，或者使用诸如Adobe Poly或的库，从C ++中的惯用（或其他）OOP过渡到更通用的多态性 Boost.TypeErasure之。