什么是智能指针,何时应该使用?
答案 0 :(得分:1788)
智能指针是一个包装“原始”(或“裸”)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
是很有用的,那就是另一个对象的生命周期。该对象一直存在,直到退出包含的代码块,或者直到包含的对象本身被销毁为止。
更复杂的智能指针策略涉及引用计数指针。这确实允许复制指针。当销毁对象的最后一个“引用”时,将删除该对象。此政策由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都定义了weak_ptr
来定义对shared_ptr
的弱(不计数)引用。
<强>更新强>
这个答案相当陈旧,因此描述了当时的“好”,这是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.
答案 1 :(得分:235)
这是现代C ++的简单答案:
std::unique_ptr
。例如,将它用作指向内存的指针,该指针在进入某个范围时被分配,并在退出范围时取消分配。std::shared_ptr
- 并且不希望在所有这些引用都已消失之前取消分配您的对象。std::weak_ptr
- 对于那些可以忽略和取消分配的引用(因此他们只是注意到该对象已消失当你试图取消引用时。)boost::
智能指针或std::auto_ptr
,除非您必须阅读特殊情况。答案 2 :(得分:105)
Smart pointer是类似指针的类型,具有一些附加功能,例如自动内存释放,引用计数等。
小型介绍可在第Smart Pointers - What, Why, Which?页上找到。
一个简单的智能指针类型是std::auto_ptr
(C ++标准的第20.4.5节),它允许在超出范围时自动释放内存,并且当异常是简单时,它比简单的指针使用更健壮。抛出,虽然不太灵活。
另一个方便的类型是boost::shared_ptr
,它实现了引用计数,并在没有对象的引用时自动释放内存。这有助于避免内存泄漏,并且易于使用来实现RAII。
主题在书"C++ Templates: The Complete Guide" by David Vandevoorde, Nicolai M. Josuttis,第20章,智能指针中有详细介绍。 涉及的一些主题:
答案 3 :(得分:38)
Chris,Sergdev和Llyod提供的定义是正确的。我更喜欢更简单的定义,只是为了让我的生活变得简单:
智能指针只是一个重载->
和*
运算符的类。这意味着你的对象在语义上看起来像一个指针,但你可以让它做更酷的事情,包括引用计数,自动销毁等。
在大多数情况下,shared_ptr
和auto_ptr
就足够了,但是还有他们自己的一套小特质。
答案 4 :(得分:28)
智能指针就像常规(类型)指针,如“char *”,除非指针本身超出范围,否则它指向的内容也会被删除。您可以像使用“ - &gt;”一样使用它,就像使用“ - &gt;”一样,但如果您需要一个指向数据的实际指针则不能。为此,您可以使用“&amp; * ptr”。
对以下内容有用:
必须使用new分配的对象,但您希望与该堆栈上的内容具有相同的生命周期。如果将对象分配给智能指针,则当程序退出该功能/块时,它们将被删除。
类的数据成员,这样当删除对象时,所有拥有的数据也会被删除,而析构函数中没有任何特殊代码(您需要确保析构函数是虚拟的,这几乎总是这是一件好事。)
您可能 想要在以下情况下使用智能指针:
另见:
答案 5 :(得分:16)
大多数类型的智能指针都会为您处理指针对象的处理。它非常方便,因为您不必再考虑手动处理对象了。
最常用的智能指针是std::tr1::shared_ptr
(或boost::shared_ptr
),不太常见的是std::auto_ptr
。我建议定期使用shared_ptr
。
shared_ptr
非常通用,可以处理各种各样的处理场景,包括需要“跨越DLL边界”传递对象的情况(如果在两者之间使用不同的libc
,常见的噩梦案例你的代码和DLL)。
答案 6 :(得分:16)
智能指针是一个像指针一样的对象,但还可以控制构造,破坏,复制,移动和解除引用。
可以实现自己的智能指针,但许多库也提供智能指针实现,每个实现都有不同的优点和缺点。
例如,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中,但现已弃用。
答案 7 :(得分:10)
以下是类似答案的链接: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);
答案 8 :(得分:8)
http://en.wikipedia.org/wiki/Smart_pointer
在计算机科学中,一个智能指针 是一种抽象数据类型 在提供时模拟指针 附加功能,如自动 垃圾收集或边界检查。 这些附加功能是有意的 减少误用造成的错误 指针同时保持效率。 智能指针通常会跟踪 指向它们的对象 内存管理的目的。该 滥用指针是一个主要来源 错误:不断分配, 必须重新分配和引用 由写的程序执行 使用指针很有可能 会发生一些内存泄漏。 智能指针试图阻止内存 通过制作资源泄漏 释放自动:当时 指向对象的指针(或指向对象的指针) 因为,系列指针被破坏了 例如,因为它超出了范围, 尖头物体也被破坏了。
答案 9 :(得分:5)
让T成为本教程中的一个类 C ++中的指针可分为3种类型:
1)原始指针:
T a;
T * _ptr = &a;
它们将内存地址保存到内存中的某个位置。请谨慎使用,因为程序变得复杂,难以跟踪。
带有const数据或地址的指针{Read backwardwards}
T a ;
const T * ptr1 = &a ;
T const * ptr1 = &a ;
指向数据类型T的指针,它是一个const。这意味着您无法使用指针更改数据类型。即*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
使用引用计数实现跟踪多少&#34;事情&#34;指向指针指向的对象。当此计数变为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
请参阅:When is std::weak_ptr useful?
唯一指针: 轻量级智能指针,拥有独家所有权。当指针指向唯一对象而不共享指针之间的对象时使用。
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 semantics
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指针,不能用更好的语法移动。
请参阅:What are the differences between a pointer variable and a reference variable in 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指出这个问题。
答案 10 :(得分:3)
智能指针是一个类,是普通指针的包装器。与普通指针不同,智能点的生命周期基于引用计数(智能指针对象分配的时间)。因此,每当智能指针被分配给另一个时,内部引用计数加上加号。每当对象超出范围时,引用计数减去负数。
自动指针虽然看起来很相似,但与智能指针完全不同。每当自动指针对象超出变量范围时,它就是一个方便的类来释放资源。在某种程度上,它使指针(动态分配的内存)的工作方式类似于堆栈变量(在编译时静态分配)。
答案 11 :(得分:2)
智能指针是指您无需担心内存分配,资源共享和传输的问题。
您可以使用与Java中的任何分配类似的方式使用这些指针。在Java中,垃圾收集器可以解决问题,而在Smart Pointers中,诀窍是由Destructors完成的。
答案 12 :(得分:1)
现有答案很好,但不包括当智能指针不是您要解决的问题的(完整)答案时该怎么做。
使用智能指针的其他内容(在其他答案中解释得很清楚)是How do we use a abstract class as a function return type?的可能解决方案,已被标记为此问题的副本。但是,第一个问题是,是否试图在C ++中将抽象(或实际上是任意)基类指定为返回类型是“你真正的意思是什么?”。在boost pointer container library的文档中,对C ++中的惯用面向对象编程(以及它与其他语言的不同之处)进行了很好的讨论(进一步参考)。总之,在C ++中,您必须考虑所有权。哪些智能指针可以帮助您,但不是唯一的解决方案,或者总是一个完整的解决方案(它们不会给您多态复制)并且并不总是您希望在界面中公开的解决方案(并且函数返回听起来很糟糕)很像一个界面)。例如,返回引用可能就足够了。但在所有这些情况下(智能指针,指针容器或只是返回引用),您已将值的返回值更改为某种形式的引用。如果你真的需要复制,你可能需要添加更多的样板“idiom”或者使用C ++中的惯用(或其他)OOP超越使用Adobe Poly或Boost.TypeErasure等库的更通用的多态性。
答案 13 :(得分:1)
什么是智能指针。
长版,原则上:
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 have
acquired any resources it needs (in the constructor).
● When an object goes out of scope, it should release every
resource 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 pointer
shared_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.