找到这个看起来很有趣的代码:
auto a = [](){};
class B : decltype(a)
{
};
我想知道它的作用.这有用吗？
从C++ 14开始,我们可以使用泛型lambdas:
auto generic_lambda = [] (auto param) {};
这基本上意味着它的调用操作符基于标记为auto的参数进行模板化.
问题是如何创建一个可以接受可变参数数量的lambda,类似于可变参数函数模板的工作方式？如果这不可能,最接近的东西可以用同样的方法吗？你会怎么存储它？有可能std::function吗？
Clang有一个很好的页面描述了C++ 1z/C++ 17特性支持的项目状态(以及C++ 11和C++ 14,它是同一页面).
g ++有一个关于C++ 14特性的页面,但我找不到任何关于C++ 17/C++ 1z的内容.这是否正在进行,但只是没有出现在网络上？对于5.0版？
我在C++中编写了一个匿名的阶乘函数,并用g ++ 4.9.2编译了我的代码.它运作良好.但是,我不知道我的功能类型.
#include<iostream>
#include<functional>
using std::function;
int main()
{
//tested at g++ 4.9.2
//g++ -std=c++1y -o anony anony.cpp
auto fac = [](auto self,auto n)->auto{
if(n < 1)
return 1;
else
return n * self(self,n-1);
};
std::cout<<fac(fac,3)<<std::endl;//6
return 0;
}
所以,我想知道:什么类型fac和self？如果我只是将C++代码翻译成Haskell,它将无法编译,因为它涉及无限类型:
fac2 self 0 = 1
fac2 self n = n * (self self $ n-1)
我必须定义一些递归类型的工作:
data Y a = Y ((Y a)->a->a)
fac2 self 0 = 1
fac2 self n = n * ((applY …假设我有以下包含lambda的变量:
auto a = [] { return true; };
我想稍后a回来false.我可以按照这个方针做点什么吗？
a = [] { return false; };
此语法给出了以下错误:
binary '=' : no operator found which takes a right-hand operand of type
'main::<lambda_a7185966f92d197a64e4878ceff8af4a>' (or there is no acceptable conversion)
IntelliSense: no operator "=" matches these operands
operand types are: lambda []bool ()->bool = lambda []bool ()->bool
有没有办法实现这样的事情？我想将auto变量更改为不同的lambda.我是一个初学者,所以我可能会错过一些关于autolambdas的知识.谢谢.
我想找到点,它具有较小的Y坐标(如果更多这样的点,找到具有最小X的那个).用lambda编写时:
std::min_element(begin, end, [](PointAndAngle& p1, PointAndAngle& p2) {
if (p1.first->y() < p2.first->y())
return true;
else if (p1.first->y() > p2.first->y())
return false;
else
return p1.first->x() < p2.first->x();
}
我正进入(状态:
error C3499: a lambda that has been specified to have a void return type cannot return a value
有什么区别:
// works
std::min_element(begin, end, [](PointAndAngle& p1, PointAndAngle& p2) {
return p1.first->y() < p2.first->y();
}
和
// does not work
std::min_element(begin, end, [](PointAndAngle& p1, PointAndAngle& p2) {
if (p1.first->y() < p2.first->y())
return true;
else …我有一个玩具示例，我想在架构上进行修改以删除Processoron的类型依赖性EmitterT：
#include <iostream>
#include <utility>
using namespace std;
struct Emitter {
void e(int) { cout << "emitting int\n";}
void e(double) { cout << "emitting double\n";}
void e(char*) { cout << "emitting char*\n";}
void e(const char*) { cout << "emitting const char*\n";}
};
template <typename EmitterT>
struct Processor {
Processor(EmitterT e) : e_{e} {}
template <typename T>
void process(T&& value) {
cout << "some processing... ";
e_(std::forward<T>(value));
}
EmitterT e_;
};
template<typename Emitter_>
Processor<Emitter_> makeProcessor(Emitter_ e) { …我们在C++ 11中获得的新auto关键字对我来说看起来非常模糊,所以我的问题是 - 它会像模板那样产生相同的编译时间吗？
关于多态lambda的同样问题:
[](auto val) {...}
这本质上是一个模板lambda - 这会影响编译时间吗？
就我而言,
#include <boost/mpl/list.hpp>
#include <algorithm>
namespace mpl = boost::mpl;
class RunAround {};
class HopUpAndDown {};
class Sleep {};
template<typename Instructions> int doThis();
template<> int doThis<RunAround>() { /* run run run.. */ return 3; }
template<> int doThis<HopUpAndDown>() { /* hop hop hop.. */ return 2; }
template<> int doThis<Sleep>() { /* zzz.. */ return -2; }
int main()
{
typedef mpl::list<RunAround, HopUpAndDown, Sleep> acts;
// std::for_each(mpl::begin<acts>::type, mpl::end<acts>::type, doThis<????>);
return 0;
};
我该如何完成？(我不知道我是否应该使用std :: for_each,只是基于另一个答案的猜测)
我正在玩这里提到的lambda"overloading" ,很快就发现我可以很方便地创建专门的lambda闭包.所以我最初是试错了,我最有希望的试验是
auto call_for_vector = [] template<typename T> (std::vector<T>) {};
然而,稍后对cppreference的看法表明,标准似乎不允许使用这种结构或类似结构.
为什么不支持此类专业化的原因是什么？
我知道可以使用SFINAE获得这种行为,但是它的可读性更低,更难写,更容易出错.当然也可以用适当的方式编写一个类operator(),但这是洙C++ 03 :-)
这种语法会有什么用处？:
一个例子,这将允许像下面的代码中那样容易的lambda"重载"
template <class F1, class F2>
struct overload_set : F1, F2
{
overload_set(F1 x1, F2 x2) : F1(x1), F2(x2) {}
using F1::operator();
using F2::operator();
};
template <class F1, class F2>
overload_set<F1,F2> overload(F1 x1, F2 x2)
{
return overload_set<F1,F2>(x1,x2);
}
auto f = overload(
[](auto&& x){ std::cout<<"call by default"<<std::endl;},
[] template<typename T>(std::vector<T>){std::cout<<"call for vector"<<std::endl;}
);
人们可以获得这种行为,例如通过使用SFINAE基于该答案中的技术,但是再次......这很糟糕.
SFINAE是否有一个简单的解决方法来获得特定的过载？