1
class A {
2
public:
3
    auto c = 2;  // 报错
4
    static auto a;  // 错误的因为静态成员变量需要在类外赋值
5
    const static auto b = 2;
6
};

1
int main() {
2
    int a = 10, b = 20;
3
    auto f1 = [] {return a; };//错误，没有捕获外部变量，因此无法访问变量a
4
    auto f2 = [&] {return a++; };//正确，使用引用的方式捕获外部变量，可读写
5
    auto f3 = [=] {return a; };//正确，使用值拷贝的方式捕获外部变量，可读
6
    auto f4 = [=] {return a++; };//错误，使用值拷贝的方式捕获外部变量，可读不能写
7
    auto f5 = [a] {return a + b; };//错误，使用拷贝的方式捕获外部变量a，没有捕获外部变量b，因此无法访问变量b
8
    auto f6 = [a, &b] {return a + (b++); };//正确，使用拷贝的方式捕获外部变量a，只读，使用引用的方式捕获外部变量b，可读写
9
    auto f7 = [=, &b] {return a + (b++); };//正确，使用值拷贝的方式捕获所有外部变量以及b的引用，b可读写，其他只读
10
    return 0;
11
}

1
class Test {
2
public:
3
    void output(int x, int y) {
4
    auto x1 = [] {return m_number; };//错误，没有捕获外部变量，不能使用类成员m_number
5
        auto x2 = [=] {return m_number + x + y; };//正确，以值拷贝的方式捕获所有外部变量
6
        auto x3 = [&] {return m_number + x + y; };//正确，以引用的方式捕获所有外部变量
7
        auto x4 = [this] {return m_number; };//正确，捕获this指针，可访问对象内部成员
8
        auto x5 = [this] {return m_number + x + y; };//错误，捕获this指针，可访问类内部成员，没有捕获到变量x和y，因此不能访问
9
        auto x6 = [this, x, y] {return m_number + x + y; };//正确，捕获this指针，x，y
10
        auto x7 = [this] {return m_number++; };//正确，捕获this指针，并且可以修改对象内部变量的值
11
    }
12
    int m_number = 100;
13
}

1
// 可以自动推导出返回值类型
2
auto f = [](int i) {
3
  return i;
4
}
5
// 不能推导出返回值类型
6
auto f1 = []() {
7
  return { 1, 2 };  // 基于列表初始化推导返回值，错误
8
}
9
// 正确显示声明了函数的返回值类型
10
auto f1 = []()->vector<int> {
11
  return { 1, 2 };  // 基于列表初始化推导返回值，错误
12
};

1
#include <iostream>
2
using namespace std;
3
#include <vector>
4
#include <algorithm>
5

6
int main() {
7
  vector<int> vec = {1,2,3,4,5,6};
8
    sort(vec.begin(), vec.end(), [](int a, int b) {
9
        return a > b;
10
    });
11
    for (auto it : vec) {
12
    cout << it << " ";
13
    }
14
}

1
#include <vector>
2
#include <algorithm>
3
using namespace std;
4
#include <iostream>
5

6
vector<int> nums;
7
vector<int> largeNums;
8
const int ubound = 10;
9
inline void LargeNumsFunc(int i) {
10
    if (i > ubound)
11
        largeNums.push_back(i);
12
}
13
void Above() {
14
  // 传统的for循环
15
    for (auto itr = nums.begin(); itr != nums.end(); ++itr) {
16
    if (*itr >= ubound)
17
            largeNums.push_back(*itr);
18
    }
19
    // 使用函数指针
20
    for_each(nums.begin(), nums.end(), LargeNumsFunc);
21
    // 使用lambda和算法for_each
22
    for_each(nums.begin(), nums.end(), [=](int i) {
23
        if (i > ubound)
24
            largeNums.push_back(i);
25
    });
26
}