[ 捕获 ] ( 形参 ) -> ret { 函数体 }
[ 捕获 ] ( 形参 ) { 函数体 }
[ 捕获 ] { 函数体 }

& 以引用隐式捕获被使用的自动变量
= 以复制隐式捕获被使用的自动变量

[&]{};          // OK：默认以引用捕获
[&, i]{};       // OK：以引用捕获，但 i 以值捕获

[=]{};          // OK：默认以复制捕获
[=, &i]{};      // OK：以复制捕获，但 i 以引用捕获

[this]{}; // 获取this指针, 如果使用了&和=则会默认包括this

// 原版
bool compare(int &a, int &b)
{
	return a > b;
}

xxx(compare);

// 新版
xxx([](int a, int b){return a > b;});

auto add = [](int a, int b){return a + b;};
int bar = add(1, 2);

using namespace std::chrono_literals;

std::this_thread::sleep_for(2000ms);

chrono::milliseconds operator"" ms(unsigned long long _Val) noexcept

#include <iostream>
#include <future>
#include <unistd.h>
int Foo()
{
	std::cout << "Foo begin" << std::endl;
	sleep(2);
	std::cout << "Foo end" << std::endl;
	return 1;
}
int main()
{
	auto get_id = std::async(Foo);

	std::cout << "Other work begin" << std::endl;
	sleep(1); // do other works
	std::cout << "Other work end" << std::endl;
	
	get_id.wait();
	std::cout << get_id.get() << std::endl;
	return 0;
}
/*
Other work begin
Foo begin
Other work end
Foo end
1
*/

##include <functional>
##include <iostream>

void PrintA()
{
    std::cout << "A" << std::endl;
}
void PrintB(int bar)
{
    std::cout << "B" << std::endl;
}
int main()
{
    std::function<void()> FPrintA = PrintA;
    FPrintA();

    std::function<void(int)> FPrintB = PrintB;
    FPrintB(1);

// 感觉配合Lambad 挺不错, 在一个函数中经常使用的功能可以这样定义
    std::function<void()> FLambad = [](){std::cout << "Lambad" << std::endl;};
    FLambad();
	
	// 不过使用auto貌似更简单
	auto ALambad = [](){std::cout << "Lambad" << std::endl;};
    ALambad();
}

$ A
$ B
$ Lambad

##include <functional>
##include <cstdio>

void f(int n1, int n2, int n3, int n4)
{
    printf("f function-->n1: %d, n2: %d, n3: %d, n4: %d\n", n1, n2, n3, n4);
}

void ff(int &n1, int& n2, const int& n3)
{
    printf("before ff function-->n1: %d, n2: %d, n3: %d\n", n1, n2, n3);
    n1 = 11;
    n2 = 22;
    // n3 = 33; 编译错误
    printf("after ff function-->n1: %d, n2: %d, n3: %d\n", n1, n2, n3);
}

int main()
{
    auto f1 = std::bind(f, std::placeholders::_2, std::placeholders::_3, 666, std::placeholders::_1);

    f1(1, 2, 3, 4, 5);
    // infunction-->n1: 2, n2: 3, n3: 666, n4: 1
    // 1 绑定_1  2绑定_2  3绑定_3   // 4 5被忽略
    // 按照 f1的顺序传入参数
    // 所以调用为 f(2, 3, 666, 1);

    int n1 = 1, n2 = 2, n3 = 3;
    auto ff1 = std::bind(ff, n1, std::ref(n2), std::cref(n3));
    n1 = -1;
    n2 = -2;
    n3 = -3;
    printf("before ff1 function-->n1: %d, n2: %d, n3: %d\n", n1, n2, n3);
    ff1(n1, n2, n3);
    printf("after ff1 function-->n1: %d, n2: %d, n3: %d\n", n1, n2, n3);
    // before ff1 function-->n1: -1, n2: -2, n3: -3
    // before ff function-- > n1: 1, n2 : -2, n3 : -3 // 这里说明了值传递 参数是绑定时就决定好了 引用参数还是可以改变的
    // after ff function-- > n1: 11, n2 : 22, n3 : -3
    // after ff1 function-- > n1: -1, n2 : 22, n3 : -3 // 引用传入成功改变, 值传入和const引用传入未变

    // std::ref 按引用传入参数 std::cref按const引用传入参数
}

int a = 0b111111111;

#include <map>
#include <iostream>
int main()
{
	std::map<int, int> id_map{{1, 2}, {3, 4}};

	for (const auto& id : id_map)
	{
		std::cout << id.first << id.second << std::endl;
	}
	for (const auto&[id1, id2] : id_map)
	{
		std::cout << id1 << id2 << std::endl;;
	}
	return 0;
}

/*
12
34
12
34
*/

int Init()
{
	return 1;
}
int main()
{
	for (int a = Init(); a != 2; a++)
	{
		std::cout << 1 << std::endl;
	}
	if (int a = Init(); a == 1)
	{
		std::cout << 1 << std::endl;
	}
	switch (int a = Init(); a)
	{
	case 1:
		std::cout << 1 << std::endl;
	}
	return 1;
}

std::optional<std::string> Foo(bool b)
{
	if (b)
	{
		return "123456";
	}
	else
	{
		return {};
	}
}
int main()
{
	if (!Foo(false).has_value())
	{
		std::cout << "no value" << std::endl; // no value
	}
	std::cout << Foo(false).value_or("(null)"); // (null)
	std::cout << Foo(true).value_or("no value"); // 123456
}

int main()
{
	const char* str = "123456789";
	std::string_view message(str, strlen(str));
	std::cout << message;
}

const char* errnum;
const char* shortmsg;
fmt::format("HTTP/1.0 {} {}\r\n", errnum, shortmsg);