具有先前参数类型匹配的参数包



所以我用一个简单的例子来尝试理解可变参数模板和一些tmp技术。该示例包含一个具有 toc(( 方法的 Timer 类。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;
};

在这里,我创建了一个带有策略的计时器,并使用参数包调用策略的 ctor。通过这种方式,我可以控制策略的工作方式(例如,我可以传递一个变量并将结果存储在那里(。

现在,我想使用这个

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

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

我尝试为计时器 ctor 添加默认参数

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

但这也会失败,因为它仍在尝试将 de string 与策略类型匹配(在这种情况下,它尝试调用第二个 ctor,因为它标记为显式。如果我删除它,它会编译,但工作错误,因为策略值不正确(。

如果我写,一切正常

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

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

无论如何,我可以避免写 std::string? 谢谢!

编辑:

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

我的方法是

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。

我误解了什么?

再次感谢!

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

喜欢:

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&&所以它与"移动"相同

如果要转发引用,则必须使用转发引用:

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

如果参数是左值引用,则此处TT&,如果参数是右值引用,则TT,通过转发引用 v 分别是T& &&,因此是T&T &&T&&;)

编辑: 如注释中所述,当您为构造函数提供计时器时,此代码不起作用。 有一些方法可以避免此问题,SFINAE 可以帮助您,例如;)

编辑 2 : 你想跟踪你的Args ...,正如你在评论中所说的那样。

假设你有一个这样的类:

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>

它的名字是演绎指南。

相关内容

  • 没有找到相关文章

最新更新