struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
//struct ComparePriceLess
struct Compare1
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
//struct ComparePriceGreater
struct Compare2
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
struct CompareEvaluateGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._evaluate > gr._evaluate;
}
};
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
//sort(v.begin(), v.end(), Compare1()); // 价格升序
//sort(v.begin(), v.end(), Compare2()); // 价格降序
//sort(v.begin(), v.end(), CompareEvaluateGreater()); // 评价的降序
sort(v.begin(), v.end(), Compare1());
sort(v.begin(), v.end(), Compare2());
return 0;
}
为什么要引入lambda?
[捕捉列表] (参数列表) mutable -> 返回值类型 { 函数体 }
//[捕捉列表] (参数列表) mutable -> 返回值类型 { 函数体 }
// 局部的匿名函数对象
auto less = [](int x, int y)->bool {return x < y; };
cout << less(1, 2) << endl;
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), Compare1());
sort(v.begin(), v.end(), Compare2());
//auto goodsPriceLess = [](const Goods& x, const Goods& y)->bool {return x._price < y._price; };
// 没有返回值时此部分可省略
auto goodsPriceLess = [](const Goods& x, const Goods& y){return x._price < y._price; };
cout << goodsPriceLess(v[0], v[1]) << endl;
sort(v.begin(), v.end(), goodsPriceLess);
sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
return x._price < y._price; });
sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
return x._price > y._price;});
sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
return x._evaluate < y._evaluate;});
sort(v.begin(), v.end(), [](const Goods& x, const Goods& y) {
return x._evaluate > y._evaluate;});
return 0;
}
lambda表达式书写格式:[capture-list] (parameters) mutable -> return-type { statement }
int main()
{
int a = 0, b = 2;
double rate = 2.555;
auto add1 = [](int x, int y)->int {return x + y; };
auto add2 = [](int x, int y) {return x + y; };//返回值类型明确情况下,也可省略,由编译器对返回类型进行推导。
}
auto add3 = [rate](int x, int y) {return (x + y)* rate; };
int a = 0;
int b = 1;
int c = 2;
int d = 3;
const int e = 1;
cout << &e << endl;
// 引用的方式捕捉所有对象,除了a
// a用传值的方式捕捉
//捕捉所有对象auto func = [&]{函数体};
auto func = [&, a] {
//a++;fail
b++;
c++;
d++;
//e++;
cout << &e << endl;
//这里程序是会报错的,可以这样理解:因为其参数默认是带const的,不能被修改
int x = 0, y = 2;
auto swap1 = [add1](int& x, int& y) {
int tmp = x;
x = y;
y = tmp;
cout << add1(x, y) << endl;
};
swap1(a, b);
int x = 0, y = 2;
auto swap1 = [x, y]() mutable {
// mutable让捕捉的x和y可以改变了,
// 但是他们依旧是外面x和y的拷贝
int tmp = x;
x = y;
y = tmp;
};
swap1();
int x = 0, y = 2;
auto swap1 = [x, y]() mutable {
// mutable让捕捉的x和y可以改变了,
// 但是他们依旧是外面x和y的拷贝
int tmp = x;
x = y;
y = tmp;
};
swap1();
// 引用的方式捕捉
int x = 0, y = 2;
auto swap2 = [&x, &y](){
int tmp = x;
x = y;
y = tmp;
};
swap2();
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);
// lambda
//[=]:表示值传递方式捕获所有父作用域中的变量(包括this)
auto r2 = [=](double monty, int year)->double {return monty * rate * year;
};
r2(10000, 2);
return 0;
}