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

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

694102 次浏览
小开

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

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

小开

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

它可用于：

  • 必须分配new的对象，但你希望与该堆栈上的某些对象具有相同的生存期。如果该对象被分配给智能指针，那么当程序退出该函数/块时，它们将被删除。

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

您可能没有想要在以下情况下使用智能指针：

  • ……指针实际上不应该拥有数据……也就是说，当你只是使用数据时，但你希望它在你引用它的函数中存活下来。
  • …智能指针本身不会在某个时候被销毁。您不希望它位于永远不会被销毁的内存中（例如在动态分配但不会被显式删除的对象中）。
  • …两个智能指针可能指向相同的数据。（然而，甚至有更智能的指针可以处理……这称为引用计数。）

另见：

小开

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

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

shared_ptr非常通用，处理各种各样的处理方案，包括需要“跨DLL边界传递对象”的情况（如果在代码和DLL之间使用不同的libc，则常见的噩梦情况）。

小开

更新：

关于过去使用的C++类型，这个答案已经过时了。
std::auto_ptr已被弃用并在新标准中删除。
应该使用#1而不是boost::shared_ptr，这是标准的一部分。

与智能指针原理背后的概念的链接仍然主要相关。

现代C++具有以下智能指针类型，并且不需要提升智能指针：

答案中还提到了该书的第2版：C++模板：完全指南第二版，作者：David Vandevoorde Nicolai， M. Josuttis， Douglas Gregor

老答案：

A智能指针是一个指针类型，具有一些附加功能，例如自动内存释放、引用计数等。

页面智能指针-什么，为什么，哪个？上有一个小介绍。

简单的智能指针类型之一是#0（C++标准的第20.4.5章），它允许在内存超出范围时自动释放内存，并且在抛出异常时比简单的指针使用更健壮，尽管灵活性较差。

另一种方便的类型是#0，它实现引用计数并在没有对对象的引用时自动释放内存。这有助于避免内存泄漏，并且易于使用来实现RAII。

该主题在第0本书第20章深入介绍。智能指针。内容介绍：

小开
最佳答案

更新

这个答案相当古老，因此描述了当时的“好”，即Boost库提供的智能指针。自C++11以来，标准库提供了足够的智能指针类型，因此您应该赞成使用#0、#1和#2。

还有#0。它非常像一个作用域指针，除了它还有被复制的“特殊”危险能力-这也出乎意料地转移了所有权。
它在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 goalMyObject* ptr = new MyObject();ptr->DoSomething(); // Use the object in some waydelete 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

使用中最简单的策略涉及智能指针包装对象的范围，例如由#0或#1实现。 

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实例。这可以防止指针被多次（错误地）删除。但是，您可以将对它的引用传递给您调用的其他函数。

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

更复杂的智能指针策略涉及对指针进行引用计数。这确实允许复制指针。当对对象的最后一个“引用”被销毁时，对象被删除。此策略由#0和#1实现。

void f(){typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short aliasMyObjectPtr p1; // Empty
{MyObjectPtr p2(new MyObject());// There is now one "reference" to the created objectp1 = 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 heapMyObjectPtr* 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 p2p2->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提供的定义是正确的。不过，我更喜欢更简单的定义，只是为了让我的生活简单：智能指针只是一个重载->和*运算符的类。这意味着您的对象在语义上看起来像一个指针，但您可以让它做更酷的事情，包括引用计数、自动销毁等。在大多数情况下，shared_ptr和auto_ptr就足够了，但也有自己的一套小特质。

小开

智能指针是一个像指针一样的对象，但还提供对构造、销毁、复制、移动和取消引用的控制。

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

例如，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 pointersmart_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);
小开

以下是现代C++（C++11及以后）的简单答案：

  • “什么是智能指针？”
    它是一种类型，其值可以像指针一样使用，但它提供了自动内存管理的附加功能：当智能指针不再使用时，它指向的内存将被释放（另见维基百科上更详细的定义）。
  • “我什么时候用一个？”
    在涉及跟踪一块内存的所有权、分配或取消分配的代码中；智能指针通常可以节省您显式执行这些操作的需要。
  • "但是在这种情况下我应该使用哪个智能指针呢？"
    • 当您希望您的对象与对它的单个拥有引用的生命一样长时，请使用#0。例如，将它用作指向内存的指针，该指针在进入某个范围时分配，在退出范围时取消分配。
    • 当您确实想从多个地方引用您的对象时，请使用#0-并且不希望您的对象被取消分配，直到所有这些引用本身消失。
    • 当您确实想从多个地方引用您的对象时，请使用#0-对于那些可以忽略和释放的引用（因此当您尝试取消引用时，他们只会注意到对象已消失）。
    • 有一个提案将危险指示器添加到C++26，但现在你没有它们。
    • 不要使用boost::智能指针或std::auto_ptr，除非在特殊情况下，如果你必须的话，你可以阅读。
  • “喂，我又没问用哪一个！”
    啊，但你真的想，承认吧。
  • “那么我什么时候应该使用常规指针呢？”
    主要是在忘记内存所有权的代码中。这通常发生在从其他地方获取指针并且不分配或取消分配并且不存储超过其执行时间的指针副本的函数中。
小开

让T成为本教程中的一个类C++中的指针可以分为3种：

1）原始指针：

T a;T * _ptr = &a;

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

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

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

指向常量数据类型T的指针。这意味着您不能使用指针更改数据类型。ie*ptr1 = 19；将不起作用。但您可以移动指针。ieptr1++ , ptr1--； etc将起作用。向后读取：指向类型T的指针，它是const

  T * const ptr2 ;

指向数据类型T的const指针。这意味着您不能移动指针，但您可以更改指针指向的值。即*ptr2 = 19将起作用，但ptr2++ ; ptr2-- etc将不起作用。向后读取：const指针指向类型T 

const T * const ptr3 ;

指向常量数据类型T的常量指针。这意味着您既不能移动指针，也不能将数据类型指针更改为指针。即。ptr3-- ; ptr3++ ; *ptr3 = 19;将不起作用

3）智能指针：{#include <memory>}

共享指针： 

  T a ;//shared_ptr<T> shptr(new T) ; not recommended but worksshared_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 functionsshptr->memFn();(*shptr).memFn();
//shptr.reset() ; // frees the object pointed to be the ptrshptr = nullptr ; // frees the objectshptr = 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_ptrwk.lock()->memFn() ; // use lock to get a shared_ptr//   ^^^ Can lead to exception if the shared ptr has gone out of scopeif(!wk.expired()) wk.lock()->memFn() ;// Check if shared ptr has gone out of scope before access

见：什么时候d::weak_ptr有用？

唯一指针：具有独占所有权的轻量级智能指针。当指针指向唯一对象时使用，而无需在指针之间共享对象。

unique_ptr<T> uptr(new T);uptr->memFn();
//T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptruptr.reset() ; // deletes the object pointed to by uptr

要更改唯一ptr指向的对象，请使用移动语义学

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指针，即一个常量指针，不能用更好的语法移动。

见：C++中的指针变量和引用变量有什么区别？ 

r-value reference : reference to a temporary objectl-value reference : reference to an object whose address can be obtainedconst reference : reference to a data type which is const and cannot be modified

参考：https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ感谢安德烈提出这个问题。

小开

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

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

小开

智能指针是一个类，是普通指针的包装器。与普通指针不同，智能指针的生命周期基于引用计数（智能指针对象被分配的时间）。因此，每当一个智能指针被分配给另一个智能指针时，内部引用计数加正。每当对象超出范围时，引用计数减去。

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

小开

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

除此之外（在其他答案中解释得很好），使用智能指针是我们如何使用抽象类作为函数返回类型？的一个可能的解决方案，它被标记为这个问题的重复。然而，如果想在C++中指定一个抽象（或事实上，任何）基类作为返回类型，要问的第一个问题是“你真正的意思是什么？”。在Boost指针容器库的留档中，有一个很好的讨论（有进一步的参考）C++中的惯用面向对象程序设计（以及这与其他语言有何不同）。总之，在C++你必须考虑所有权。哪些智能指针可以帮助你，但不是唯一的解决方案，或者总是一个完整的解决方案（它们不会给你多态副本），并且并不总是你想在接口中公开的解决方案（函数返回听起来非常像一个接口）。例如，返回一个引用可能就足够了。但是在所有这些情况下（智能指针、指针容器或简单地返回一个引用），你已经将返回从值更改为某种形式的参考。如果你真的需要复制，你可能需要添加更多样板“ideom”或超越惯用（或其他）OOP，C++使用adobePoly或打字擦除等库来实现更通用的多态。

小开

什么是智能指针？

长版本，原则上：

https://web.stanford.edu/class/archive/cs/cs106l/cs106l.1192/lectures/lecture15/15_RAII.pdf

现代C++成语：

RAII: Resource Acquisition Is Initialization.
● When you initialize an object, it should already haveacquired any resources it needs (in the constructor).

● When an object goes out of scope, it should release everyresource it is using (using the destructor).

关键点：

● There should never be a half-ready or half-dead object.● When an object is created, it should be in a ready state.● When an object goes out of scope, it should release its resources.● The user shouldn’t have to do anything more.

原始指针违反RAII：当指针超出范围时，需要用户手动删除。

RAII解决方案是：

Have a smart pointer class:● Allocates the memory when initialized● Frees the memory when destructor is called● Allows access to underlying pointer

对于需要复制和共享的智能指针，使用shared_ptr：

● use another memory to store Reference counting and shared.● increment when copy, decrement when destructor.● delete memory when Reference counting is 0.also delete memory that store Reference counting.

对于智能指针不拥有原始指针，请使用weak_ptr：

● not change Reference counting.

shared_ptr用法：

correct way:std::shared_ptr<T> t1 = std::make_shared<T>(TArgs);std::shared_ptr<T> t2 = std::shared_ptr<T>(new T(Targs));
wrong way:T* pt = new T(TArgs); // never exposure the raw pointershared_ptr<T> t1 = shared_ptr<T>(pt);shared_ptr<T> t2 = shared_ptr<T>(pt);

始终避免使用原始指针。

对于必须使用原始指针的场景：

https://stackoverflow.com/a/19432062/2482283

对于不是nullptr的原始指针，请改用引用。

not use T*use T&

对于可能为nullptr的可选引用，使用原始指针，这意味着：

T* pt; is optional reference and maybe nullptr.Not own the raw pointer,Raw pointer is managed by some one else.I only know that the caller is sure it is not released now.

提交答案