我正在使用传统的C API,在这种API下,获取某些资源非常昂贵,并且释放该资源绝对至关重要。我正在使用C ++ 14,我想创建一个类来管理这些资源。这是事物的基本骨架......
class Thing
{
private:
void* _legacy;
public:
void Operation1(...);
int Operation2(...);
string Operation3(...);
private:
Thing(void* legacy) :
_legacy(legacy)
{
}
};
这不是单身人士模式。没有什么是静态的,可能有很多Thing
个实例,它们都在管理自己的遗留资源。此外,这不仅仅是一个智能指针。包装指针_legacy
是私有的,所有操作都通过一些公共实例函数公开,这些函数隐藏了消费者的遗留API。
构造函数是私有的,因为Thing
的实例将从静态工厂或实际获取资源的 named-constructor 返回。这是对该工厂的廉价模仿,使用malloc()
作为调用遗留API的代码的占位符......
public:
static Thing Acquire()
{
// Do many things to acquire the thing via the legacy API
void* legacy = malloc(16);
// Return a constructed thing
return Thing(legacy);
}
这是负责释放遗留资源的析构函数,free()
只是一个占位符......
~Thing() noexcept
{
if (nullptr != _legacy)
{
// Do many things to free the thing via the legacy API
// (BUT do not throw any exceptions!)
free(_legacy);
_legacy = nullptr;
}
}
现在,我想确保只有一个Thing
实例管理一个遗留资源。我不希望Thing
类的使用者随意传递实例 - 它们必须直接或通过unique_ptr
本地拥有到类或函数,或者包含shared_ptr
。可以传递的。为此,我删除了赋值运算符和复制构造函数......
private:
Thing(Thing const&) = delete;
void operator=(Thing const&) = delete;
然而,这增加了额外的挑战。要么我必须更改我的工厂方法以返回unique_ptr<Thing>
或shared_ptr<Thing>
,要么我必须实现移动语义。我不想指定应该使用Thing
的模式,所以我选择添加一个move-constructor和move-assignment-operator,如下所示......
Thing(Thing&& old) noexcept : _legacy(old._legacy)
{
// Reset the old thing's state to reflect the move
old._legacy = nullptr;
}
Thing& operator= (Thing&& old) noexcept
{
if (&old != this)
{
swap(_legacy, old._legacy);
}
return (*this);
}
完成所有这些后,我可以使用Thing
作为本地并移动它...
Thing one = Thing::Acquire();
Thing two = move(one);
我无法通过尝试提交自我分配来破坏模式:
Thing one = Thing::Acquire();
one = one; // Build error!
我也可以将unique_ptr
改为一个......
auto three = make_unique<Thing>(Thing::Acquire());
或shared_ptr
...
auto three = make_shared<Thing>(Thing::Acquire());
一切都按照我的预期运作,我的析构函数在我所有测试中的恰当时刻运行。事实上,唯一的烦恼是make_unique
和make_shared
实际调用了移动构造函数 - 它没有像我希望的那样被优化掉。
第一个问题:我是否正确实施了 move -constructor和move-assignment-operator? (他们对我来说相当新,这将是我第一次愤怒地使用它。)
第二个问题:请评论此模式!这是将遗留资源包装在C ++ 14类中的好方法吗?
最后:我是否应该更改任何内容以使代码更好,更快,更简单或更易读?
答案 0 :(得分:6)
您应该将Thing
包装在智能指针中,然后您不必担心复制和移动语义。
class Thing
{
private:
void* _legacy;
public:
void Operation1(...);
int Operation2(...);
string Operation3(...);
Thing(const Thing&) = delete;
Thing(Thing&&) = delete;
Thing& operator=(const Thing&) = delete;
Thing& operator=(Thing&&) = delete;
static std::shared_ptr<Thing> acquire() {
return std::make_shared<Thing>();
}
private:
Thing() : _legacy(malloc(16)) {
// ...
}
~Thing() {
free(_legacy);
}
};
同样,您可以使用unique_ptr
:
std::unique_ptr<Thing> acquire() {
return std::make_unique<Thing>();
}
你似乎暗示你只想拥有这个东西的一个实例,尽管在你的解决方案中你并没有尝试做那样的事情。为此你需要静态变量。虽然请记住,在这种情况下,只有在main()
函数退出后才会释放资源。例如:
static std::shared_ptr<Thing> acquire() {
static std::shared_ptr<Thing> instance;
if (!instance) {
instance = std::make_shared<Thing>();
}
return instance;
}
或unique_ptr
版本:
static Thing& acquire() {
static std::unique_ptr<Thing> instance;
if (!instance) {
instance = std::make_unique<Thing>();
}
return *instance;
}
或者,您可以使用weak_ptr
获取程序范围内的一个实例,当没有人使用它时会释放该实例。在这种情况下,您将无法使用unique_ptr
来实现此目的。如果该对象被释放然后再次需要,则该版本将重新创建该对象。
static std::shared_ptr<Thing> acquire() {
static std::weak_ptr<Thing> instance;
if (instance.expired()) {
instance = std::make_shared<Thing>();
}
return instance.lock();
}
答案 1 :(得分:2)
struct free_thing{
void operator()(void* p)const{
// stuff
free(p);
}
};
using upthing=std::unique_ptr<void,free_thing>;
upthing make_thing(stuff){
void*retval;
// code
return upthing(retval);
}
将upthing
存储在Thing
_legacy
。使用默认dtor,移动ctor,移动Thing
(=default
)的分配。
销毁代码进入free_thing
。
你的ctor创造了一切。
现在,用户可以将您的Thing
视为仅限移动值类型。
除非确实需要,否则不要编写自己的指针管理器。独特和共享为您做很多事情:如果您编写自己的智能指针,请将它们用作内部内容。