什么是智能指针,什么时候应该使用?
当前回答
更新
这个答案相当陈旧,因此描述了当时的“好”,这是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实例。这可以防止指针被多次删除(错误地)。但是,您可以将对它的引用传递给您调用的其他函数。
当您想要将对象的生存期与特定的代码块绑定时,或者如果您将其作为成员数据嵌入到另一个对象中,那么uniqueptrs非常有用。该对象一直存在,直到包含代码块退出,或者直到包含对象本身被销毁。
更复杂的智能指针策略涉及对指针进行引用计数。这允许复制指针。当对象的最后一个“引用”被破坏时,该对象将被删除。此策略由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的弱(未计数)引用。
其他回答
Chris、Sergdev和Llyod提供的定义是正确的。我更喜欢一个更简单的定义,只是为了让我的生活简单:智能指针只是一个重载->和*运算符的类。这意味着你的对象在语义上看起来像一个指针,但你可以让它做一些更酷的事情,包括引用计数、自动销毁等。sharedptr和autoptr在大多数情况下都是足够的,但它们也有自己的一些小特点。
以下是类似答案的链接: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);
智能指针是一个类,是普通指针的包装。与普通指针不同,智能指针的生命周期基于引用计数(智能指针对象被分配的次数)。因此,每当智能指针分配给另一个指针时,内部引用计数加上。每当对象超出范围时,引用计数减。
自动指针,虽然看起来类似,但与智能指针完全不同。这是一个方便的类,每当自动指针对象超出变量范围时,它就释放资源。在某种程度上,它使指针(指向动态分配的内存)的工作方式类似于堆栈变量(在编译时静态分配)。
下面是现代C++(C++11及更高版本)的一个简单答案:
“什么是智能指针?”这是一种类型,其值可以像指针一样使用,但它提供了自动内存管理的附加功能:当智能指针不再使用时,它指向的内存将被释放(另请参阅维基百科上更详细的定义)。“我什么时候该用?”在涉及跟踪内存所有权、分配或取消分配的代码中;智能指针通常不需要显式地执行这些操作。“但在这些情况下,我应该使用哪个智能指针?”当您希望对象的生存时间与对它的单个拥有引用的生存时间一样长时,请使用std::unique_ptr。例如,将它用作指向内存的指针,该指针在进入某个作用域时分配,在退出作用域时取消分配。当您确实希望从多个位置引用对象时,请使用std::shared_ptr,并且不希望在所有这些引用都消失之前取消分配对象。当您确实希望从多个位置引用对象时,请使用std::weak_ptr-对于那些可以忽略和取消分配的引用(因此当您尝试取消引用时,它们会注意到对象已消失)。有人建议在C++26中添加危险指针,但目前还没有。不要使用boost::smart指针或std::auto_ptr,除非在特殊情况下,您可以在必要时阅读。“嘿,我没问该用哪一个!”啊,但你真的想承认。“那么,我什么时候应该使用常规指针?”大部分代码都忽略了内存所有权。这通常发生在从其他地方获取指针的函数中,它们既不分配也不取消分配,也不存储指针的副本,该副本的执行时间会延长。
现有的答案很好,但不包括当智能指针不是您试图解决的问题的(完整)答案时该做什么。
除了其他事情(在其他答案中解释得很好)之外,使用智能指针是如何将抽象类用作函数返回类型的一个可能的解决方案?该问题被标记为该问题的副本。然而,如果想在C++中指定抽象(或实际上任何)基类作为返回类型,首先要问的问题是“你真正的意思是什么?”。boost指针容器库的文档中对C++中惯用的面向对象编程(以及这与其他语言的区别)进行了很好的讨论(并提供了进一步的参考)。总之,在C++中,您必须考虑所有权。哪些智能指针可以帮助您,但不是唯一的解决方案,或者总是一个完整的解决方案(它们不会为您提供多态副本),也不总是您希望在接口中公开的解决方案。例如,返回引用就足够了。但是在所有这些情况下(智能指针、指针容器或简单地返回引用),您已经将返回从值更改为某种形式的引用。如果你真的需要复制,你可能需要添加更多的样板“习惯用法”,或者使用Adobe Poly或Boost.TypeErasure等库从C++中的惯用(或其他)OOP过渡到更通用的多态性。
推荐文章
- 为什么我的程序不能在Windows 7下用法语编译?
- 如何获取变量的类型?
- 什么是奇怪的重复模板模式(CRTP)?
- 连接两个向量的最佳方法是什么?
- 在c++中,是通过值传递更好,还是通过引用到const传递更好?
- 在STL中deque到底是什么?
- Windows上最好的免费c++分析器是什么?
- 如何自动转换强类型枚举为int?
- 在一个类中使用具有成员函数的泛型std::function对象
- 'for'循环中的后增量和前增量产生相同的输出
- 虚函数和纯虚函数的区别
- c++中的_tmain()和main()有什么区别?
- 内存泄漏是否正常?
- 当启用c++ 11时,std::vector性能回归
- 什么时候使用哪种指针?