在下面的程序中,当不使用mutable
时,程序将无法编译。
#include <iostream>
#include <queue>
#include <functional>
std::queue<std::function<void()>> q;
template<typename T, typename... Args>
void enqueue(T&& func, Args&&... args)
{
//q.emplace([=]() { // this fails
q.emplace([=]() mutable { //this works
func(std::forward<Args>(args)...);
});
}
int main()
{
auto f1 = [](int a, int b) { std::cout << a << b << "\n"; };
auto f2 = [](double a, double b) { std::cout << a << b << "\n";};
enqueue(f1, 10, 20);
enqueue(f2, 3.14, 2.14);
return 0;
}
这是编译器错误
lmbfwd.cpp: In instantiation of ‘enqueue(T&&, Args&& ...)::<lambda()> [with T = main()::<lambda(int, int)>&; Args = {int, int}]’:
lmbfwd.cpp:11:27: required from ‘struct enqueue(T&&, Args&& ...) [with T = main()::<lambda(int, int)>&; Args = {int, int}]::<lambda()>’
lmbfwd.cpp:10:2: required from ‘void enqueue(T&&, Args&& ...) [with T = main()::<lambda(int, int)>&; Args = {int, int}]’
lmbfwd.cpp:18:20: required from here
lmbfwd.cpp:11:26: error: no matching function for call to ‘forward<int>(const int&)’
func(std::forward<Args>(args)...);
我无法理解为什么没有mutable
时参数转发失败。
此外,如果我传递带有字符串作为参数的lambda,则不需要mutable
并且程序可以工作。
#include <iostream>
#include <queue>
#include <functional>
std::queue<std::function<void()>> q;
template<typename T, typename... Args>
void enqueue(T&& func, Args&&... args)
{
//works without mutable
q.emplace([=]() {
func(std::forward<Args>(args)...);
});
}
void dequeue()
{
while (!q.empty()) {
auto f = std::move(q.front());
q.pop();
f();
}
}
int main()
{
auto f3 = [](std::string s) { std::cout << s << "\n"; };
enqueue(f3, "Hello");
dequeue();
return 0;
}
为什么在int double
情况下需要可变的,而在string
情况下为什么不可变的?这两者之间有什么区别?
答案 0 :(得分:18)
非mutable
的lambda会在其const
重载时生成带有隐式operator()
限定符的 closure类型。
std::forward
是有条件的举动:当提供的模板参数不是左值引用时,它等效于std::move
。定义如下:
template< class T >
constexpr T&& forward( typename std::remove_reference<T>::type& t ) noexcept;
template< class T >
constexpr T&& forward( typename std::remove_reference<T>::type&& t ) noexcept;
(请参阅:https://en.cppreference.com/w/cpp/utility/forward)。
让我们将代码段简化为:
#include <utility>
template <typename T, typename... Args>
void enqueue(T&& func, Args&&... args)
{
[=] { func(std::forward<Args>(args)...); };
}
int main()
{
enqueue([](int) {}, 10);
}
clang++ 8.x
产生的错误是:
error: no matching function for call to 'forward' [=] { func(std::forward<Args>(args)...); }; ^~~~~~~~~~~~~~~~~~ note: in instantiation of function template specialization 'enqueue<(lambda at wtf.cpp:11:13), int>' requested here enqueue([](int) {}, 10); ^ note: candidate function template not viable: 1st argument ('const int') would lose const qualifier forward(typename std::remove_reference<_Tp>::type& __t) noexcept ^ note: candidate function template not viable: 1st argument ('const int') would lose const qualifier forward(typename std::remove_reference<_Tp>::type&& __t) noexcept ^
在上面的代码段中:
Args
是int
,是指lambda之外的类型。
args
是指通过lambda捕获合成的闭包成员,由于缺少const
而成为mutable
。
因此std::forward
调用是...
std::forward<int>(/* `const int&` member of closure */)
...这与std::forward
的任何现有重载都不匹配。提供给forward
的模板参数与其函数参数类型之间不匹配。
将mutable
添加到lambda使得args
不为const
,并且找到了合适的forward
重载(第一个重载其参数)。
通过使用C ++ 20压缩扩展捕获来“重写” args
的名称,我们可以避免上面提到的不匹配,即使没有mutable
也可以编译代码:
template <typename T, typename... Args>
void enqueue(T&& func, Args&&... args)
{
[func, ...xs = args] { func(std::forward<decltype(xs)>(xs)...); };
}
为什么在
mutable
的情况下需要int double
而在string
的情况下为什么没有要求?这两者之间有什么区别?
这很有趣-之所以起作用,是因为您实际上并未在调用中传递std::string
:
enqueue(f3, "Hello");
// ^~~~~~~
// const char*
如果您正确地将传递给enqueue
的参数类型与f3
接受的参数类型匹配,它将按预期停止工作(除非您使用mutable
或C ++ 20功能):
enqueue(f3, std::string{"Hello"});
// Compile-time error.
要说明带有const char*
的版本为何起作用,让我们再次看一个简化的示例:
template <typename T>
void enqueue(T&& func, const char (&arg)[6])
{
[=] { func(std::forward<const char*>(arg)); };
}
int main()
{
enqueue([](std::string) {}, "Hello");
}
Args
推导为const char(&)[6]
。有一个匹配的forward
重载:
template< class T >
constexpr T&& forward( typename std::remove_reference<T>::type&& t ) noexcept;
替换后:
template< class T >
constexpr const char*&& forward( const char*&& t ) noexcept;
这只是返回t
,然后将其用于构造std::string
。