我正在尝试编写一个符合 RAII 的资源包装器，但我被困在如何形成模板参数的语义上。

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

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

或者我可以把它写成一个仿函数:

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&) 这样的版本，因为它不会绑定(bind)到 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
};

最佳答案

做

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 中的另一种方法将是所有值(value)而不是所有类型。

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

并教导资源保持值(value)给他们的删除者。这导致 int_cleaner获取存储空间并在资源中产生值(value)。

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) {}
};

或类似的东西。

关于c++ - 可以接受函数指针或 Functor 的模板参数，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46530173/