C++ 使用可变参数模板编译时间特定的函数

Question

我目前正在开发一个函数抽象库。我想将多参数函数抽象为作为索引的单参数函数。 （可选）我想传递一个谓词对象来确定它是否应该运行代码。

using FnType = std::function<void(const unsigned long)>;

template<typename Fn, typename Predicate, typename ... Args>
const FnType make_fn(const Fn &fn, const Predicate &predicate, Args ... args) {
    return [&](const unsigned long idx) {
        if(predicate(idx)) fn(idx, args ...);
    };
}

template<typename Fn, typename ... Args>
const FnType make_fn(const Fn &fn, Args ... args) {
    return [&](const unsigned long idx) {
        fn(idx, args ...);
    };
}

此代码在使用谓词时完美运行。

std::vector<double> data(10);
auto fn = [&](unsigned idx, double d) { data[idx] *= d; };
auto pred = [](unsigned long idx) { return idx % 2 == 0; };
FnType new_fn = make_fn(fn, pred, 2.0);

但是当我尝试不传递谓词时

FnType new_fn2 = make_fn(fn, 2.0);

它返回以下编译时错误消息：

called object type 'double' is not a function or function pointer
    if(predicate(idx)) fn(idx, args ...);
       ^~~~~~~~~

有没有可能说编译器应该使用不使用任何谓词的第二个函数？

Answer 1

让我们看看你的签名：

template<typename Fn, typename Predicate, typename ... Args>
const FnType make_fn(const Fn&, const Predicate&, Args ...); // (1)

template<typename Fn, typename ... Args>
const FnType make_fn(const Fn&, Args ... ) // (2)

当我们打电话时：

make_fn(fn, 2.0);

Predicate 没有什么特别之处——它只是另一种类型。因此，当我们进行重载解析时，我们有两个完全匹配。我们解析可变参数的方式是(1) 比(2) 更专业——因为(1) 至少需要2 个参数，(2) 至少需要1 个参数，所以前者更具体。这就是为什么我们称之为前者。编译器从签名中不知道Predicate 是什么意思。

最简单的解决方案是简单地重命名一个函数或另一个 - 你真的需要重载它们吗？有一个make_fn() 和一个make_predicate_fn()。

或者，我们可以使用 SFINAE 更改它，通过强制 Predicate 是可调用的：

template <typename Fn, typename Predicate, typename... Args,
          typename = decltype(std::declval<Predicate>()(0u))>
const FnType make_fn(const Fn&, const Predicate&, Args ...);

这会使(1) 不适合您的通话，因此首选(2)。虽然这也有一个缺点，如果你不想以这种方式使用谓词，而是简单地有一些函数，其第一个参数是一个谓词？会发生错误的事情。

T.C. 提出的更好的解决方案。在 cmets 中只是引入一个空标签类型：

struct predicate_tag_t { };
constexpr predicate_tag_t predicate_tag{}; 

并在该标签的存在上超载：

template <typename Fn, typename Predicate, typename... Args>
FnType make_fn(const Fn&, predicate_tag_t, const Predicate&, Args&&... );

template <typename Fn, typename... Args>
FnType make_fn(const Fn&, Args&&... );

这样你的例子就变成了：

FnType new_fn = make_fn(fn, predicate_tag, pred, 2.0);
FnType new_fn2 = make_fn(fn, 2.0);

---

当你有两个make_fns 时，你有悬空引用：

const FnType make_fn(const Fn &fn, Args ... args) {
    return [&](const unsigned long idx) { ... }
}

您正在复制所有参数，然后保存对所有参数的引用。但是一旦make_fn 完成，所有args 都会超出范围。您需要复制它们 - 所以[=]。

Answer 2

将你的上层函数更改为

template<typename Fn, typename Predicate, typename ... Args
       , typename = std::enable_if_t<sizeof ... (Args) != 0> >
const FnType make_fn(const Fn &fn, const Predicate &predicate, Args ... args) {
    return [=](const unsigned long idx) {
        if(predicate(idx)) fn(idx, args ...);
    };
}

这确保了参数包中至少有一个成员，然后在重载解析期间选择第二个函数。

还有一些注意事项：

• 最好将返回类型设为auto——您仍然可以将其分配给std::function，但如果您只是调用它，则需要更少的开销。

• 可能你不想通过值传递Args ...中的通用参数，所以最好写Args const& ... args。