可以接受函数指针或 Functor 的模板参数

Question

我正在尝试编写一个符合 RAII 标准的资源包装器，但在如何形成模板参数的语义方面陷入困境。

例如，我可以编写一个函数来删除我的资源：

void int_cleaner(int val) {
    std::cout << "Value of " << val << " has been cleaned up." << std::endl;
}

或者我可以把它写成 Functor：

struct int_deleter {
    void operator()(int val) const {
        std::cout << "Value of " << val << " has been cleaned up." << std::endl;
    }
};

但这就是我卡住的地方：如果我想将它传递给我的资源包装器，我必须更改模板参数的定义方式。

如果我这样写resource：

template<typename T, typename Deleter>
class resource {
};

这适用于仿函数，但不适用于函数本身。

int main() {
    resource<int, int_deleter> res; //Compiles fine
    //resource<int, int_cleaner> res2; //Does Not Compile
    return 0;
}

相反，如果我这样写模板参数：

template<typename T>
using deleter_t = void(*)(T);

template<typename T, deleter_t<T> Deleter>
class resource {
};

int main() {
    //resource<int, int_deleter> res; //Does Not Compile
    resource<int, int_cleaner> res2; //Compiles fine
    return 0;
}

现在，我可以编写两个版本的代码，但我不想这样做有两个原因：

1. 我只是复制resource 的定义，如果我需要对其中一个进行更改，我也需要对另一个进行更改。
2. 接受函数指针的版本不会接受像void cleaner(T const&) 这样的版本，因为它不会绑定到void(*)(T)。所以我还需要再制作两个或三个版本，以便我可以处理T、T&、T const& 和T&&。

我怎样才能以最小化代码重复的方式编写资源包装器，特别是考虑到函数版本和函数指针版本之间的删除机制会有所不同？

//example:
template<typename T>
using deleter_t = void(*)(T);

template<typename T, deleter_t<T> Deleter>
class resource {
~resource() {Deleter(val);}
};
template<typename T, typename Deleter>
class resource {
~resource() {Deleter{}(val);}//Note the subtle syntax change
};

Answer 1

做

template<typename T, typename Deleter>
class resource {
};

然后写

template<auto k>
using constant_t = std::integral_constant<std::decay_t<decltype(k)>, k>;
template<auto k>
constexpr constant_t<k> constant{};

现在你的 main 看起来像这样：

int main() {
  resource<int, int_deleter> res; //Compiles fine
  resource<int, constant_t<int_cleaner>> res2; //Also compiles fine
  return 0;
}

我们完成了。

Live example.

这是c++17。

在c++14 中，您必须将constant_t<foo> 替换为std::integral_constant<std::decay_t<decltype(foo)>, foo>，因为它缺少auto 模板参数。

在c++11 integral_constant 中不能使用函数指针，让你调用它们。您必须编写派生类型：

namespace notstd {
  template<class T, T t>
  struct integral_constant:std::integral_constant<T, t> {
    constexpr operator T()const{ return this->get(); }
  }
}

并将std::integral_constant 替换为notstd::integral_constant 以启用该功能。 （隐式转换为函数指针就足以允许在整数常量上使用调用运算符）。

在c++03 中，你会想要一个新的编译器。

---

c++17 中的另一种方法是使用所有值而不是所有类型。

resource foo(7, int_deleter{});
resource foo2(7, int_cleaner);

并教导资源持有价值给他们的删除者。这会导致int_cleaner 占用存储空间并在资源中具有价值。

resource foo(7, int_deleter{});
resource foo2(7, constant<int_cleaner>);

回到最初的计划，我们通过将int_cleaner 提升到类型系统中来制作无状态指针。

通过使用 EBO，resource 可以以零开销存储无状态删除器。

---

请注意，您的resource 看起来很多类似于unique_ptr<T, Deleter>，其中Deleter::pointer 是一个薄包装的std::optional<T>（用于可空性）。

template<class T>
struct nullable_opt:std::optional<T> {
  using std::optional<T>::optional;
  nullable_opt( nullable_opt const& ) = default;
  nullable_opt( nullable_opt && ) = default;
  nullable_opt& operator=( nullable_opt const& ) = default;
  nullable_opt& operator=( nullable_opt && ) = default;
  nullable_opt() = default;

  nullable_opt(std::nullptr_t) {}
};

或类似的。

Answer 2

您的模板参数是类型。要从“值”中获取类型，您可以使用decltype。比如说

resource<int, decltype(int_cleaner)> res2;

您仍然需要将实际函数作为参数传递给某个函数（例如构造函数），因为您无法从函数类型创建实例。

我建议您查看执行相同操作的标准类，例如std::unique_ptr。也许您应该使用哪个而不是创建自己的类？或者std::shared_ptr？