我想创建一个类,其中客户端可以存储lambda表达式,如类[]() -> void {}的字段,但我无法弄清楚如何这样做. 一个答案建议使用decltype,我尝试没有成功.这是一个ideone源链接.以下是来源和结果:
#include <cstdio>
auto voidLambda = []()->void{};
class MyClass {
public:
decltype(voidLambda) t;
MyClass(decltype(voidLambda) t) {
this->t = t;
}
};
int main() {
MyClass([] {
printf("hi");
});
}
结果:
prog.cpp: In constructor 'MyClass::MyClass(<lambda()>)':
prog.cpp:3:79: error: no matching function for call to '<lambda()>::__lambda0()'
prog.cpp:2:20: note: candidates are: <lambda()>::<lambda>(const<lambda()>&)
prog.cpp:2:20: note: <lambda()>::<lambda>(<lambda()>&&)
prog.cpp:3:88: error: no match for 'operator=' in '((MyClass*)this)->MyClass::t = t'
prog.cpp: In function 'int main()':
prog.cpp:5:27: error: no matching …我有以下代码(c ++ 11):
template <typename F,
typename FirstT,
typename... FIn>
auto min_on(F f, FirstT first, FIn... v) -> typename std::common_type<FirstT, FIn...>::type
{
using rettype = typename std::common_type<FirstT, FIn...>::type;
using f_rettype = decltype(f(first));
rettype result = first;
f_rettype result_trans = f(first);
f_rettype v_trans;
(void)std::initializer_list<int>{
((v_trans = f(v), v_trans < result_trans)
? (result = static_cast<rettype>(v), result_trans = v_trans, 0)
: 0)...};
return result;
}
这基本上返回result产生表达式最小值的参数f(result).这可以像这样调用:
auto mod7 = [](int x)
{
return x % 7;
};
auto minimum …c++ lambda template-meta-programming variadic-templates c++11
我有一个接受函数作为参数的模板.
当我尝试传递lambda表达式时,它不会编译.
typedef int (*func)(int a);
template <func foo>
int function(int a)
{
foo(a);
}
int test(int a)
{
return a;
}
int main()
{
function<test>(1); // ---> this is ok
auto lambda = [](int a) -> int { return a; };
function<lambda>(1); // ---> this is wrong, why?
return 0;
}
我错过了什么？
我发现那些类似的问题Lambda表达式作为类模板参数和如何使用lambda表达式作为模板参数？,但即使有可用的答案我也不明白为什么以下代码不起作用(g ++ 4.8.2和g ++ - 4.9):
auto GoLess = [](int a,int b) -> bool
{
return a < b;
};
template<typename Order>
struct foo
{
int val;
bool operator<(const foo& other)
{
return Order(val, other.val);
}
};
typedef foo<decltype(GoLess)> foo_t;
int main()
{
foo_t a,b;
bool r = a < b;
}
编译器输出是:
test.cpp: In instantiation of ‘bool foo<Order>::operator<(const foo<Order>&) [with Order = <lambda(int, int)>]’:
test.cpp:26:15: required from here
test.cpp:17:30: error: no matching function for call …可能重复:
lambda函数可以模板化吗？
是否可以使用模板参数的c ++ 0x lambda？例如:
template <typename T> [=](const T *x) {}
我想要做的是在类型列表(可变参数列表)上编写静态for循环,并且我想将当前类型作为参数传递给目标仿函数(或lambda)的operator().
require 子句中的表达式是否b<[]{ return true; }()>符合 C++20 标准？由于某种原因，GCC 拒绝它并认为它是表达式错误，而 MSVC 和 Clang 接受它。
template<bool B>
inline constexpr bool b = B;
static_assert(requires { b<[]{ return true; }()>; });
GCC的错误信息：
<source>:3:15: error: static assertion failed
3 | static_assert(requires { b<[]{ return true; }()>; });
| ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
<source>:3:15: note: constraints not satisfied
<source>:3:26: note: the required expression 'b<<expression error> >' is invalid,
because
3 | static_assert(requires { b<[]{ return true; }()>; });
| ^~~~~~~~~~~~~~~~~~~~~~~
假设我有一个标题wrapper.h:
template <typename Func> void wrapper(const Func func);
和一个文件wrapper.cpp包含:
#include "wrapper.h"
template <typename Func>
void wrapper(const Func func)
{
func();
}
并且文件main.cpp包含:
#include "wrapper.h"
#include <iostream>
int main()
{
wrapper( [](){std::cout<<"hello."<<std::endl;} );
}
如果我一起编译这些(例如cat wrapper.cpp main.cpp | g++ -std=c++11 -o main -x c++ -),我没有链接器错误.
但是如果我单独编译它们(例如g++ -std=c++11 -o wrapper.o -c wrapper.cpp && g++ -std=c++11 -o main main.cpp wrapper.o),我当然---得到一个链接器错误:
Undefined symbols for architecture x86_64:
"void wrapper<main::$_0>(main::$_0)", referenced from:
_main in …我正在尝试构建一个具有递归能力的 lambda 自作用域的干净整洁的实现（这基本上是一个 Y 组合器，尽管我认为技术上不完全）。这是一个旅程，它带我到许多其他人中，这个线程，这个线程和这个线程。
我已经尽可能干净地归结了我的问题之一：如何传递以 lambda 作为模板参数的模板化函子？
#include <string>
#include <iostream>
#define uint unsigned int
template <class F>
class Functor {
public:
F m_f;
template <class... Args>
decltype(auto) operator()(Args&&... args) {
return m_f(*this, std::forward<Args>(args)...);
}
};
template <class F> Functor(F)->Functor<F>;
class B {
private:
uint m_val;
public:
B(uint val) : m_val(val) {}
uint evaluate(Functor<decltype([](auto & self, uint val)->uint {})> func) const {
return func(m_val);
}
};
int main() {
B b = B(5u); …