struct Goods
{
string _name; //名字
double _price; //价格
int _num; //数量
};
struct ComparePriceLess
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._price < g2._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._price > g2._price;
}
};
struct CompareNumLess
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._num < g2._num;
}
};
struct CompareNumGreater
{
bool operator()(const Goods& g1, const Goods& g2)
{
return g1._num > g2._num;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2, 20 }, { "香蕉", 3, 30}, { "橙子", 4,40 }, { "菠萝", 5,50 } };
sort(v.begin(), v.end(), ComparePriceLess()); //按Goods价格升序排序
sort(v.begin(), v.end(), ComparePriceGreater()); //按Goods价格降序排序
sort(v.begin(), v.end(), CompareNumLess()); //按Goods升序排序
sort(v.begin(), v.end(), CompareNumGreater()); //按Goods降序排序
return 0;
}
在C++11后,我们便可以通过lamada表达式来解决,lamada表达式实际上就是一个匿名函数,这样我们即可通过lamada表达式直接了解sort排序的比较方式,进而提高了代码的可读性.
int main()
{
vector<Goods> v = { { "苹果", 2.1, 300 }, { "香蕉", 3.3, 100 }, { "橙子", 2.2, 1000 }, { "菠萝", 1.5, 1 } };
sort(v.begin(), v.end(), []( const Goods& g1,const Goods& g2) {return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {return g1._price < g2._price; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._num < g2._num; });
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) { return g1._num < g2._num; });
return 0;
}
lamada表达式的书写格式:
[capture-list] (parameters) mutable -> return-type
{
statement
}
lambda表达式的简单运用
int mian()
{
//由于lambda表达式实际上就是一个匿名对象,没有函数名不好调用,但是我们可以通过auto自动获取.
auto add1 = [](int a, int b) { return a + b; }; //省略返回值.
cout << add1(1, 2) << endl;
}
捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式为传值还是传引用.
lambda表达式中未使用捕获列表和使用捕获列表对比.
如果我们不适用捕获列表,我们就要额外写函数形参,在调用时也必须将实参传过去,这样过于麻烦.
int main()
{
//之前做法
int x = 0,y = 1;
auto swap1 = [](int& x1, int& x2) { int tmp = x1; x1 = x2; x2 = tmp;};
swap1(x, y);
return 0;
}
所以,我们可以使用捕获列表,又因为传值捕获过来的x,y通常是不可以被修改的(可以使用mutable修饰符),并且此时捕获过来的x,y仅仅为实参的拷贝,此时,我们一般采用引用捕捉,这样让代码更加简洁.
int main()
{
auto swap2 = [&x, &y] {int tmp = x; x = y; x = tmp;}; //引用捕捉.
swap2(); //不需要传递实参.
cout << x << ":" << y << endl;
}
捕捉列表其他特性的简单运用
int main()
{
int a, b, c, d, e;
auto f1 = [=] {cout << a << b << d << e; }; //a,b,c,d,e全部传值捕获.
f1();
auto f2 = [=, &a] { a++; cout << a << b << c << d << e; }; //b,c,d,e传值捕获,a传引用捕获.
f2();
}
但是注意,捕获列表不允许变量重复传递,否则就会导致编译错误.
int main()
{
int a, b, c, d, e;
auto f = [=,a] {cout << a << b << d << e; }; //重复捕获.
}
编译器对于lambda的处理,实际上和仿函数的处理一样.
为了对lambda表达式的底层原理进行验证,我们分别写了一个仿函数和一个lambda表达式,他们的功能相同.
class Rate
{
public:
Rate(double rate) : _rate(rate)
{}
double operator()(double money, int year)
{
return money * _rate * year;
}
private:
double _rate;
};
int main()
{
// 函数对象
double rate = 0.49;
Rate r1(rate);
r1(10000, 2);
// lamber表达式
auto r2 = [=](double monty, int year)->double {return monty * rate * year;
};
r2(10000, 2);
return 0;
}
当我们对仿函数和lambda表达式分别调用时,转到反汇编查看.
总结: