##include <iostream>
##include <future>
##include <thread>
using namespace std;
int find_result_to_add()
{ 
    // std::this_thread::sleep_for(std::chrono::seconds(2)); // 用来测试异步延迟的影响
    std::cout << "find_result_to_add" << std::endl;
    return 1 + 1;
} 
int find_result_to_add2(int a, int b)
{ 
    // std::this_thread::sleep_for(std::chrono::seconds(5)); // 用来测试异步延迟的影响
    return a + b;
} 
void do_other_things()
{
    std::cout << "do_other_things" << std::endl;
    // std::this_thread::sleep_for(std::chrono::seconds(5));
} 
int main()
{
    // std::async(find_result_to_add) 的意思是将函数放到一个异步线程去运行，说明这里不会阻塞do_other_things
    std::future<int> result = std::async(find_result_to_add); 
    // std::future<decltype (find_result_to_add())> result = std::async(find_result_to_add);
    // auto result = std::async(find_result_to_add); // 推荐的写法
    do_other_things();
    // get会阻塞等待异步线程有返回值
    std::cout << "result: " << result.get() << std::endl; // 延迟是否有影响？



    // std::future<decltype (find_result_to_add2(int, int))> result2 = std::async(find_result_to_add2, 10, 20); //错误
    std::future<decltype (find_result_to_add2(0, 0))> result2 = std::async(find_result_to_add2, 10, 20);
    std::cout << "result2: " << result2.get() << std::endl; // 延迟是否有影响？
    // std::cout << "main finish" << endl;
    return 0;
}

##include <iostream>
##include <future>
using namespace std;
int add(int a, int b, int c)
{
    std::cout << "call add\n";
    return a + b + c;
} 
void do_other_things()
{
    std::cout << "do_other_things" << std::endl;
} 
int main()
{
    std::packaged_task<int(int, int, int)> task(add); // 封装任务，并不会直接运行
    do_other_things();
    std::future<int> result = task.get_future(); // 这里也不会运行
    task(1, 1, 2); //必须要让任务执行，否则在get()获取future的值时会一直阻塞
    std::cout << "result:" << result.get() << std::endl;
    return 0;
}

##include <future>
##include <string>
##include <thread>
##include <iostream>
using namespace std;
void print(std::promise<std::string>& p)
{
    p.set_value("There is the result whitch you want.");
} 
void do_some_other_things()
{
    std::cout << "Hello World" << std::endl;
} 
int main()
{
    std::promise<std::string> promise;
    std::future<std::string> result = promise.get_future();
    std::thread t(print, std::ref(promise));
    do_some_other_things();
    std::cout << result.get() << std::endl;
    t.join();
    return 0;
}

##include <iostream>
##include <functional>
using namespace std;
//保存普通函数
void func1(int a)
{
    cout << a << endl;
} 
//保存成员函数
class A{
public:
    A(string name) : name_(name){}
    void func3(int i) const {cout <<name_ << ", " << i << endl;}
private:
    string name_;
};
int main()
{
    cout << "main1 -----------------" << endl;
    //1. 保存普通函数
    std::function<void(int a)> func1_;
    func1_ = func1;
    func1_(2); //2
    cout << "\n\nmain2 -----------------" << endl;
    //2. 保存lambda表达式
    std::function<void()> func2_ = [](){cout << "hello lambda" << endl;};
    func2_(); //hello world
    cout << "\n\nmain3 -----------------" << endl;
    //3 保存成员函数
    std::function<void(const A&,int)> func3_ = &A::func3;
    A a("darren");
    func3_(a, 1);
    return 0;
}

##include <iostream>
##include <functional>
using namespace std;
class A
{ 
public:
    // 重载fun_3，主要bind的时候需要
    // std::bind((void(A::*)(int, int))&A::fun_3
    void fun_3(int k,int m)
    {
        cout << "fun_3 a = " << a<< endl;
        cout<<"print: k="<<k<<",m="<<m<<endl;
    }
    // std::bind((void(A::*)(string))&A::fun_3
    void fun_3(string str) {
        cout<<"print: str="<<str<<endl;
    } 
    int a;
};
void fun_1(int x,int y,int z)
{
    cout<<"fun_1 print: x=" <<x<<",y="<< y << ",z=" <<z<<endl;
} 
void fun_2(int &a,int &b)
{
    a++;
    b++;
    cout<<"print: a=" <<a<<",b="<<b<<endl;
} 
int main()
{ 

    //f1的类型为 function<void(int, int, int)>
    cout << "\n\nstd::bind(fun_1, 1, 2, 3) -----------------\n";
    auto f1 = std::bind(fun_1, 1, 2, 3); //表示绑定函数 fun 的第一，二，三个参数值为：1 2 3
    f1(); //print: x=1,y=2,z=3
    cout << "\n\nstd::bind(fun_1, 10, 20, 30) -----------------\n";
    auto f11 = std::bind(fun_1, 10, 20, 30); //表示绑定函数 fun 的第一，二，三个参数值为： 1 2 3
    f11();
    cout << "\n\nstd::bind(fun_1, placeholders::_1,placeholders::_2, 3) -----------------\n";
    auto f2 = std::bind(fun_1, placeholders::_1, placeholders::_2, 3);
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f2 的第一，二个参数指定
    f2(1,2);//print: x=1,y=2,z=3
    f2(10,21,30); // 传入30也没有用

    cout << "\n\nstd::bind(fun_1,placeholders::_2,placeholders::_1,3) -----------------\n";
    auto f3 = std::bind(fun_1,placeholders::_2,placeholders::_1,3);
    //表示绑定函数 fun 的第三个参数为 3，而fun 的第一，二个参数分别由调用 f3 的第二，一个参数指定
    //注意： f2 和 f3 的区别。
    f3(1,2);//print: x=2,y=1,z=3
    
    cout << "\n\nstd::bind(fun_2, placeholders::_1, n) -----------------\n";
    int m = 2;
    int n = 3;
    auto f4 = std::bind(fun_2, placeholders::_1, n); //表示绑定fun_2的第一个参数为n, fun_2的第二个参数由调用f4的第一个参数（_1）指定。
    f4(m); //print: m=3,n=4
    cout<<"m="<<m<<endl;//m=3 说明：bind对于不事先绑定的参数，通过std::placeholders传递的参数是通过引用传递的,如m
    cout<<"n="<<n<<endl;//n=3 说明：bind对于预先绑定的函数参数是通过值传递的，如n


    cout << "\n\nstd::bind(&A::fun_3, &a,placeholders::_1,placeholders::_2) -----------------\n";
    A a;
    a.a = 10;
    //f5的类型为 function<void(int, int)>
    auto f5 = std::bind((void(A::*)(int, int))A::fun_3, &a, 40, 50); //使用auto关键字
    f5(10,20);//调用a.fun_3(10,20),print: k=10,m=20

    cout << "\n\nstd::bind(&A::fun_3, &a2,placeholders::_1,placeholders::_2) -----------------\n";
    A a2;
    a2.a = 20;
    //f5的类型为 function<void(int, int)>
    auto f6 = std::bind((void(A::*)(int, int))&A::fun_3, &a2,placeholders::_1,placeholders::_2); //使用auto关键字f6(10,20);//
    cout << "\n\nstd::bind(&A::fun_3,a,std::placeholders::_1,std::placeholders::_2) -----------------\n";
    
    std::function<void(int,int)> fc = std::bind((void(A::*)(int,int))&A::fun_3, a,std::placeholders::_1,std::placeholders::_2);
    fc(10,20); //调用a.fun_3(10,20) print: k=10,m=20
    fc = std::bind((void(A::*)(int, int))&A::fun_3,a2,std::placeholders::_1,std::placeholders::_2);
    
    cout << "\n\nstd::bind(&A::fun_3, a,std::placeholders::_1,std::placeholders::_2) -----------------\n";
    auto f_str = std::bind((void(A::*)(string))&A::fun_3,a,std::placeholders::_1);
    f_str("darren");

    return 0;
}