我有一个带有 unique_ptr 成员的类。
class Foo {
private:
std::unique_ptr<Bar> bar;
...
};
Bar 是具有 create() 函数和 destroy() 函数的第三方类。
如果我想std::unique_ptr在一个独立的函数中使用它，我可以这样做：
void foo() {
std::unique_ptr<Bar, void(*)(Bar*)> bar(create(), [](Bar* b){ destroy(b); });
...
}
std::unique_ptr作为班级成员，有没有办法做到这一点？
假设createanddestroy是具有以下签名的免费函数（从 OP 的代码片段中似乎就是这种情况）：
Bar* create();
void destroy(Bar*);
Foo你可以这样写你的课
class Foo {
std::unique_ptr<Bar, void(*)(Bar*)> ptr_;
// ...
public:
Foo() : ptr_(create(), destroy) { /* ... */ }
// ...
};
请注意，您不需要在此处编写任何 lambda 或自定义删除器，因为destroy它已经是一个删除器。
可以使用 C++11 中的 lambda 干净地做到这一点（在 G++ 4.8.2 中测试）。
鉴于此可重用typedef：
template<typename T>
using deleted_unique_ptr = std::unique_ptr<T,std::function<void(T*)>>;
你可以写：
deleted_unique_ptr<Foo> foo(new Foo(), [](Foo* f) { customdeleter(f); });
例如，使用FILE*：
deleted_unique_ptr<FILE> file(
fopen("file.txt", "r"),
[](FILE* f) { fclose(f); });
有了这个，您可以获得使用 RAII 进行异常安全清理的好处，而无需尝试/捕获噪音。
您只需要创建一个删除器类：
struct BarDeleter {
void operator()(Bar* b) { destroy(b); }
};
并将其作为 的模板参数提供unique_ptr。您仍然需要在构造函数中初始化 unique_ptr：
class Foo {
public:
Foo() : bar(create()), ... { ... }
private:
std::unique_ptr<Bar, BarDeleter> bar;
...
};
据我所知，所有流行的 c++ 库都正确实现了这一点；由于BarDeleter 实际上没有任何状态，因此不需要在unique_ptr.
除非您需要能够在运行时更改删除器，否则我强烈建议您使用自定义删除器类型。例如，如果为您的删除器使用函数指针，sizeof(unique_ptr<T, fptr>) == 2 * sizeof(T*). 换句话说，unique_ptr对象的一半字节被浪费了。
但是，编写一个自定义删除器来包装每个函数是一件麻烦事。幸运的是，我们可以在函数上编写一个模板类型：
从 C++17 开始：
template <auto fn>
struct deleter_from_fn {
template <typename T>
constexpr void operator()(T* arg) const {
fn(arg);
}
};
template <typename T, auto fn>
using my_unique_ptr = std::unique_ptr<T, deleter_from_fn<fn>>;
// usage:
my_unique_ptr<Bar, destroy> p{create()};
在 C++17 之前：
template <typename D, D fn>
struct deleter_from_fn {
template <typename T>
constexpr void operator()(T* arg) const {
fn(arg);
}
};
template <typename T, typename D, D fn>
using my_unique_ptr = std::unique_ptr<T, deleter_from_fn<D, fn>>;
// usage:
my_unique_ptr<Bar, decltype(&destroy), destroy> p{create()};
您知道，使用自定义删除器并不是最好的方法，因为您必须在整个代码中提及它。
相反，只要涉及自定义类型并且您尊重语义，您就可以向命名空间级别的类添加特化，请执行以下操作：::std
template <>
struct ::std::default_delete<Bar> {
default_delete() = default;
template <class U>
constexpr default_delete(default_delete<U>) noexcept {}
void operator()(Bar* p) const noexcept { destroy(p); }
};
也许还可以std::make_unique()：
template <>
inline ::std::unique_ptr<Bar> ::std::make_unique<Bar>() {
auto p = create();
if (!p)
throw std::runtime_error("Could not `create()` a new `Bar`.");
return { p };
}
您可以简单地使用std::bind您的销毁功能。
std::unique_ptr<Bar, std::function<void(Bar*)>> bar(create(), std::bind(&destroy,
std::placeholders::_1));
但当然你也可以使用 lambda。
std::unique_ptr<Bar, std::function<void(Bar*)>> ptr(create(), [](Bar* b){ destroy(b);});
使用 lambda，您可以获得与 plain 相同的大小std::unique_ptr。比较尺寸：
plain: 8
lambda: 8
fpointer: 16
std::function: 40
这是以下的输出。（我在类的范围之外声明了 lambda。不确定是否可以在类内确定它的范围。）
#include <iostream>
#include <memory>
#include <functional>
struct Bar {};
void destroy(Bar* b) {}
Bar* create() { return 0; }
auto lambda_destroyer = [](Bar* b) {destroy(b);};
class Foo {
std::unique_ptr<Bar, decltype(lambda_destroyer)> ptr_;
public:
Foo() : ptr_(create(), lambda_destroyer) { /* ... */ }
};
int main()
{
std::cout << "plain: " << sizeof (std::unique_ptr<Bar>) << std::endl
<< "lambda: " << sizeof (std::unique_ptr<Bar, decltype(lambda_destroyer)>) << std::endl
<< "fpointer: " << sizeof (std::unique_ptr<Bar, void(*)(Bar*)>) << std::endl
<< "std::function: " << sizeof (std::unique_ptr<Bar, std::function<void(Bar*)>>) << std::endl;
}
我相当确信这是目前最好的方法：
#include <memory>
#include <stdio.h>
template <typename T, auto fn>
struct Deleter
{
void operator()(T *ptr)
{
fn(ptr);
}
};
template <typename T, auto fn>
using handle = std::unique_ptr<T, Deleter<T, fn>>;
using file = handle<FILE, fclose>;
int main()
{
file f{fopen("a.txt", "w")};
return 0;
}
因为您在 unique_ptr 的模板参数中指定了一个 Functor 作为删除器，所以在调用其构造函数时不需要设置删除器。
Deleter 仿函数使用“模板自动”将删除函数（在本例中：fclose）作为模板参数，因此这需要 C++17。
扩展它以支持其他类型只是每种类型的一个额外的“使用”行。