c语言智能指针是什么,c – 什么是智能指针,什么时候应该使用？

UPDATE

这个答案相当陈旧,因此描述了当时的“好”,这是Boost库提供的智能指针.从C 11开始,标准库提供了足够的智能指针类型,因此您应该支持使用std::unique_ptr,std::shared_ptr和std::weak_ptr.

还有std::auto_ptr.它非常像一个范围指针,除了它还具有“特殊”危险的复制能力 – 这也意外地转移了所有权！它在最新标准中已弃用,因此您不应使用它.请改用std::unique_ptr.

std::auto_ptr p1 (new MyObject());

std::auto_ptr 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 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

void f()

{

{

std::unique_ptr 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 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 other;

};

std::shared_ptr p1 (new Owner());

std::shared_ptr 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的弱(不计数)引用.