完美转发 l-value ref 和 r-value ref 和非 ref 类型的可变参数模板?
Perfect forwarding variadic templates of l-value ref and r-value ref and non-ref types?
在我的程序中,我有模板 类,它们主要是用于特殊用途的包装器 std::function<..>。最小的例子是:
template <typename... Args>
class Foo {
public:
explicit Foo(std::function<void(Args&&...)> _function)
: function_(_function)
{}
template<typename... Arguments>
void Bar(Arguments&&... _args) {
function_(std::forward<Arguments>(_args)...);
}
private:
std::function<void(Args&&...)> function_;
};
这些模板的实例通常是左值引用、右值引用或无引用类型的组合。问题在于,当某些参数是非引用类型(例如 int 或 std::vector)时,调用 Bar 会导致错误。解决方法是声明一个临时变量,然后将其移动到函数调用中。
int main(){
Foo<int> test1([](int x) { });
const int x = 1;
test1.Bar(x); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'const int'
int tmp = x;
test1.Bar(tmp); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'int'
test1.Bar(std::move(tmp)); // [OK] But I don't want to have to reassign and move every time I use this.
/* I want perfect forwarding on variables that can be forwarded. */
/* There are cases when the templates are like this with a combination of l-value ref and r-value ref and non-ref types. */
Foo<const std::vector<uint8_t>&, std::vector<uint8_t>&&, int> test2([](const std::vector<uint8_t>&, std::vector<uint8_t>&&, int) { });
test2.Bar(std::vector<uint8_t>(1, 2), std::vector<uint8_t>(1, 2), x); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'const int'
return 1;
}
我希望能够将 Bar 与任何模板参数一起使用,而不必每次都重新分配和 std::move(),而且还可以完美转发 ref 参数。有没有办法做到这一点?
编辑
在网上浏览了一下之后 - 问题是 std::function<void(Args&&...)> function_;
不是采用通用引用而是采用 r-val 引用的函数。因此尝试转发无引用类型会引发错误。
那么接下来的问题是,是否可以拥有并存储一个采用通用引用的 std::function?
在std::function<void(Args&&...)>
中,你实际上期望的是r值引用,你可能想要std::function<void(Args...)>
:
template <typename... Args>
class Foo {
public:
explicit Foo(std::function<void(Args...)> _function)
: function_(_function)
{}
template <typename... Arguments>
void Bar(Arguments&&... _args) {
function_(std::forward<Arguments>(_args)...);
}
private:
std::function<void(Args...)> function_;
};
如果合适,你可以去掉std::function
:
template <typename F>
class Foo {
public:
explicit Foo(F f) : f(f) {}
template <typename... Ts>
auto operator ()(Ts&&... args) const
-> decltype(f(std::forward<Ts>(args)...))
{
return f(std::forward<Ts>(args)...);
}
private:
F f;
};
template <typename F>
Foo<F> MakeFoo(F f) { return Foo<F>{f}; }
在我的程序中,我有模板 类,它们主要是用于特殊用途的包装器 std::function<..>。最小的例子是:
template <typename... Args>
class Foo {
public:
explicit Foo(std::function<void(Args&&...)> _function)
: function_(_function)
{}
template<typename... Arguments>
void Bar(Arguments&&... _args) {
function_(std::forward<Arguments>(_args)...);
}
private:
std::function<void(Args&&...)> function_;
};
这些模板的实例通常是左值引用、右值引用或无引用类型的组合。问题在于,当某些参数是非引用类型(例如 int 或 std::vector)时,调用 Bar 会导致错误。解决方法是声明一个临时变量,然后将其移动到函数调用中。
int main(){
Foo<int> test1([](int x) { });
const int x = 1;
test1.Bar(x); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'const int'
int tmp = x;
test1.Bar(tmp); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'int'
test1.Bar(std::move(tmp)); // [OK] But I don't want to have to reassign and move every time I use this.
/* I want perfect forwarding on variables that can be forwarded. */
/* There are cases when the templates are like this with a combination of l-value ref and r-value ref and non-ref types. */
Foo<const std::vector<uint8_t>&, std::vector<uint8_t>&&, int> test2([](const std::vector<uint8_t>&, std::vector<uint8_t>&&, int) { });
test2.Bar(std::vector<uint8_t>(1, 2), std::vector<uint8_t>(1, 2), x); // [Error] cannot bind rvalue reference of type 'int&&' to lvalue of type 'const int'
return 1;
}
我希望能够将 Bar 与任何模板参数一起使用,而不必每次都重新分配和 std::move(),而且还可以完美转发 ref 参数。有没有办法做到这一点?
编辑
在网上浏览了一下之后 - 问题是 std::function<void(Args&&...)> function_;
不是采用通用引用而是采用 r-val 引用的函数。因此尝试转发无引用类型会引发错误。
那么接下来的问题是,是否可以拥有并存储一个采用通用引用的 std::function?
在std::function<void(Args&&...)>
中,你实际上期望的是r值引用,你可能想要std::function<void(Args...)>
:
template <typename... Args>
class Foo {
public:
explicit Foo(std::function<void(Args...)> _function)
: function_(_function)
{}
template <typename... Arguments>
void Bar(Arguments&&... _args) {
function_(std::forward<Arguments>(_args)...);
}
private:
std::function<void(Args...)> function_;
};
如果合适,你可以去掉std::function
:
template <typename F>
class Foo {
public:
explicit Foo(F f) : f(f) {}
template <typename... Ts>
auto operator ()(Ts&&... args) const
-> decltype(f(std::forward<Ts>(args)...))
{
return f(std::forward<Ts>(args)...);
}
private:
F f;
};
template <typename F>
Foo<F> MakeFoo(F f) { return Foo<F>{f}; }