gpt4 book ai didi

c++ - 什么是智能指针,我应该什么时候使用它?

转载 作者:bug小助手 更新时间:2023-10-28 01:29:50 36 4
gpt4 key购买 nike

什么是智能指针,我应该什么时候使用?

最佳答案

更新

这个答案相当陈旧,因此描述了当时的“好”,即 Boost 库提供的智能指针。从 C++11 开始,标准库已经提供了足够多的智能指针类型,所以你应该赞成使用 std::unique_ptr , std::shared_ptrstd::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_ptrs 在您想将对象的生命周期与特定代码块联系起来时很有用,或者如果您将其作为成员数据嵌入到另一个对象中,则该对象的生命周期其他对象。该对象一直存在,直到退出包含代码块,或者直到包含对象本身被销毁。

更复杂的智能指针策略涉及对指针进行引用计数。这确实允许复制指针。当对象的最后一个“引用”被销毁时,该对象被删除。此政策由 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.

当您的对象的生命周期要复杂得多,并且不直接绑定(bind)到特定代码部分或另一个对象时,引用计数指针非常有用。

引用计数指针有一个缺点——可能会创建一个悬空引用:

// 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 的弱(未计数)引用。

关于c++ - 什么是智能指针,我应该什么时候使用它?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/106508/

36 4 0
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com