正确使用shared_ptr来消除跨DLL边界的释放
我正在阅读“在dll接口中使用shared_ptr”。在那篇文章中，phlipsy 在其回答的最后提出了一种跨 DLL 边界传递不特定于实现的对象的方法。基本上，这个想法是从 DLL 返回一个原始指针，并使用该原始指针在 EXE 中初始化 shared_ptr。
我认为这是不正确的。为了简单起见，让我重新设计它。
// wrong version??
// DLL
Object* createObject()
{
return new Object;
}
// EXE
std::tr1::shared_ptr<Object> p(createObject());
..
当object被释放时，shared_ptr使用的销毁上下文/堆与构造期间DLL中使用的不同。
使用shared_ptr的正确方法是，资源分配应该与shared_ptr的初始化在同一行，以便分配和释放可以使用相同的堆，如下所示如下所示。
// right version
// DLL
std::tr1::shared_ptr<Object> createObject()
{
return std::tr1::shared_ptr<Object>(new Object);
}
// EXE
std::tr1::shared_ptr<Object> p(createObject());
..
我说得对吗？
I'm reading "Using shared_ptr in dll-interfaces". In that post, phlipsy suggested a way to pass no implementation specific object across DLL boundaries, at the end of his answer. Basically, the idea is to return a raw pointer from DLL and initialize the shared_ptr in EXE w/ that raw pointer.
I don't think it's correct. Let me reprototype it for simplicity.
// wrong version??
// DLL
Object* createObject()
{
return new Object;
}
// EXE
std::tr1::shared_ptr<Object> p(createObject());
..
When object is deallocated, the destruction context/heap used by shared_ptr is different from that used in DLL during construction.
The right way to use shared_ptr is that resource allocation should be in the same line w/ the initialization of shared_ptr, so that the allocation and deallocation can use the same heap, as shown below.
// right version
// DLL
std::tr1::shared_ptr<Object> createObject()
{
return std::tr1::shared_ptr<Object>(new Object);
}
// EXE
std::tr1::shared_ptr<Object> p(createObject());
..
Am I right?
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（2）
你这两种说法都是对的。第二种正确的方法是通过 createObject(..) 返回一个原始指针，用它初始化一个shared_ptr，并将一个自定义删除器传递给shared_ptr。自定义删除器是一个库函数，例如releaseObject(..)。
编辑：
使用您的版本（createObject(..) 返回一个shared_ptr<..>），您将绑定到库和库用户的特定shared_ptr 实现。按照我提议的方式，这个限制就消失了。
You're right with both statements. A second correct way would be to return a raw pointer by createObject(..), initialize a shared_ptr with it and pass a custom deleter to the shared_ptr. The custom deleter is a library function like releaseObject(..).
Edit:
With your version (createObject(..) returns a shared_ptr<..>) you're bound to a specific shared_ptr implementation of the library and the library user. In my proposed way this restriction is gone.
一般规则是分配/释放内存应始终从同一模块完成。因此，您可以使用分配器创建一个共享指针，该分配器调用分配模块中正确的释放方法。
即使您将原始指针包装在智能指针中，适用于原始指针的规则仍然适用。
The general rule is that allocating/deallocating memory should always be done from the same module. Thus, you can create a shared pointer with an allocator that calls the correct deallocation method in the allocating module.
The rules that apply to raw pointers still apply, even if you've wrapped them in a smart pointer.