如何安全地重载std::unique_ptr的自定义deleter

Question

在使用std::unique_ptr和它的自定义deleter时，我正在努力减少代码重复。

我有一些容器Foo、Bar，它们是使用一个自定义分配器分配的，因此无法使用delete释放。

所以目前的代码是：

struct UniqueFooDeleter
{
void operator()(Foo* foo) 
{
internal_free(foo);
}
};
using unique_foo_ptr = std::unique_ptr<Foo, UniqueFooDeleter>;
struct UniqueBarDeleter 
{
void operator()(Bar* bar) 
{
internal_free(bar);
}
};
using unique_bar_ptr = std::unique_ptr<Bar, UniqueBarDeleter>;

我把它改成：

struct UniqueInternalDeleter
{
void operator()(Bar* bar)
{
internal_free(bar);
}
void operator()(Foo* foo)
{
internal_free(foo);
}
};
using unique_bar_ptr = std::unique_ptr<Bar, UniqueInternalDeleter>;
using unique_foo_ptr = std::unique_ptr<Foo, UniqueInternalDeleter>;

如何做得更好，以便通过internal_free分配的任何数量的容器都可以用作std::unique_ptr？

Answer 1

如果T不是Foo或bar，则可以将UniqueInternalDeleter作为模板函子和static_assert。

#include <type_traits> // std::is_same_v
template<typename T>
struct UniqueInternalDeleter /* final */
{
static_assert(std::is_same_v<T, Foo> || std::is_same_v<T, Bar>,
" T must be either Foo or Bar");
void operator()(T* barOrfoo)
{
internal_free(barOrfoo);
}
private:
void internal_free(T* barOrfoo)
{
if constexpr(std::is_same_v<T, Foo>)
// code for `Foo*`
else
// code for `Bar*`
}
};

这使得您的别名对Bar和Foo:更加具体

using unique_bar_ptr = std::unique_ptr<Bar, UniqueInternalDeleter<Bar>>;
using unique_foo_ptr = std::unique_ptr<Foo, UniqueInternalDeleter<Foo>>;

Answer 2

一种可能的方法：

template<class> struct needs_internal_free : std::false_type { };
struct unique_internal_deleter {
template<class T>
void operator()(T* ptr) const {
static_assert(needs_internal_free<T>::value);
internal_free(ptr);
}
};
template<class T>
using unique_internal_ptr = std::unique_ptr<T, unique_internal_deleter>;

现在我们可以声明特定类型：

template<> struct needs_internal_free<Foo> : std::true_type { };
using unique_foo_ptr = unique_internal_ptr<Foo>;
template<> struct needs_internal_free<Bar> : std::true_type { };
using unique_bar_ptr = unique_internal_ptr<Bar>;