与先前参数类型匹配的参数包

Question

所以我使用一个简单的示例来尝试理解可变参数模板和一些 tmp 技术。该示例由具有 toc() 方法的 Timer class 组成。 toc 方法用于停止计时器并调用决定要做什么的函数（打印它，将其保存在变量中...）

所以我把这个想法编码成这样（我删除了计时位）

class VerbosePolicy {
public:
    VerbosePolicy() {}

    explicit VerbosePolicy(const std::string &message) : m_message(message) {}

    VerbosePolicy(VerbosePolicy &&other) { m_message = other.m_message; }

    void operator()(double time) { std::cout << m_message << time << std::endl; }

private:
    std::string m_message;
};

template <typename Policy, typename... Args> class Timer {
public:
    Timer(Args... args) : m_policy(Policy(std::forward<Args>(args)...)) {}

    void toc(double time) { m_policy(time); }

private:
    Policy m_policy;
};

这里我创建了一个带有Policy的Timer，并用参数包调用了Policy的ctor。这样我就可以控制策略的工作方式（例如，我可以传递一个变量并将结果存储在那里）。

现在，我想用这个

int main(int argc, char **argv) {
    std::string string = "Elapsed time";
    Timer<VerbosePolicy> timer(string);
    timer.toc(1.0);
}

这里的问题是编译器无法确定该字符串是参数包的一部分，并且它试图将它与策略时间匹配，但失败了。

我已经尝试为 Timer ctor 添加默认参数

Timer(Args... args, Policy policy = Policy())

但这也失败了，因为它仍在尝试将 de string 与策略类型匹配（在这种情况下，它尝试调用第二个 ctor，但失败了，因为它被标记为显式。如果我删除它，它会编译，但由于策略值不正确而导致错误）。

如果我写就一切正常

Timer<VerbosePolicy, std::string> timer(string)

因为它不再需要推导可变参数模板。

有没有办法避免写std::string？谢谢！

编辑：

因此，为了完整并解决有效答案的评论中提到的一些问题，我一直在尝试在参数与 Timer 的类型相同时停用可变参数构造函数，但没有成功。

我的方法是

template <typename T, typename... Tail> struct first_of { using type = T; };

template <typename Policy> class Timer {
public:
  template <
      typename... CArgs,
      std::enable_if_t<!std::is_same<Timer<Policy>,
                                     typename first_of<CArgs...>::type>::value,
                       int> = 0>
  Timer(CArgs &&... args) : m_policy(std::forward<CArgs>(args)...) {}

  Timer(const Timer<Policy> &other) : m_policy(other.m_policy) {}

  void toc(double time) { m_policy(time); }

private:
  Policy m_policy;
};

int main(int argc, char **argv) {
  std::string string = "Elapsed time";
  Timer<VerbosePolicy> timer(string);
  Timer<VerbosePolicy> timer2(timer);
  timer.toc(1.0);
}

但是编译器仍然尝试使用 timer2 的可变参数构造函数。我不确定为什么要这样做，因为传递给 std::is_same 的两种类型应该相等，因此应该停用 ctor。

我误会了什么？

再次感谢！

Answer 1

您是否尝试制作构造函数模板？

喜欢：

template <typename Policy> class Timer {
public:
    template<typename ...Args>
    Timer(Args && ... args) : m_policy(std::forward<Args>(args)...) {}

    void toc(double time) { m_policy(time); }

private:
    Policy m_policy;
};

顺便说一句，您使用 std::forward 的方式不对。你正在做的是：

template<typename T>
void foo(T v) {
    std::forward<T>(v);
}

在这样的代码中，T是一个非参考值。所以在这里转发意味着：T&& 所以它与 "move"

相同

如果要转发引用，必须使用转发引用:

template<typename T>
void foo(T &&v) {
    std::forward<T>(v);
}

如果参数是左值引用，这里T是一个T&，如果参数是右值引用，T是一个T并通过转发参考 v 分别是 T& && 所以 T& 和 T && 所以 T&& ;)

编辑：如评论中所述，当您向构造函数提供 Timer 时，此代码不起作用。有一些方法可以避免这个问题，例如 SFINAE 可以帮助您 ;)

编辑 2：正如您在评论中所说，您想跟踪您的 Args ...。

假设您有这样的 class :

template<typename ...Args>
class Foo {
public:
    Foo(Args... args) : noexcept m_tuple{std::move(args)...} {}
private:
    std::tuple<Args...> m_tuple;
};

你想推断类型：有两种方法：

1) C++ 17 之前：

template<typename ...Args>
Foo<Args...> make_foo(Args ...args) {
    return {args...};
}

auto d = make_foo(5, 3.0); // Foo<int, double>

2) 在 c++ 17

之后

template<typename ...Args>
Foo(Args...) -> Foo<Args...>;

Foo foo{3.0, "Lol"s}; // Foo<double, std::string>

这个名字叫推导指南。

与先前参数类型匹配的参数包

Parameter pack with pervious parameter type match

c++

templates

c++14

sfinae

variadic