c++11 学习

#include <iostream>       // std::cout
#include <functional>     // std::ref
#include <thread>         // std::thread
#include <future>         // std::promise, std::future


void print_int1(int& value) {
    std::cout << "value1: " << value << '
'; // 打印 value: 10.
    value = 5;
}

void print_int2(int value) {
    std::cout << "value2: " << value << '
'; // 打印 value: 10.
    value = 5;
}

int main ()
{
    int value1 = 10;
    int value2 = 20;
    std::thread t1(print_int1, std::ref(value1));
    t1.join();

    std::thread t2(print_int2, value2);
    t2.join();
    std::cout << "value1: " << value1 << '
'; // 打印 value: 10.
    std::cout << "value2: " << value2 << '
'; // 打印 value: 10.
    return 0;
}

g++ future.cpp -std=c++1y -g -pthread

.输出：

value1: 10
value2: 20
value1: 5
value2: 20

可见，当函数 print_int1(int&),且std::ref(value1) 时，是传递的引用。

#include <functional>
#include <iostream>
 
void f(int& n1, int& n2, const int& n3)
{
    std::cout << "In function: " << n1 << ' ' << n2 << ' ' << n3 << '
';
    ++n1; // increments the copy of n1 stored in the function object
    ++n2; // increments the main()'s n2
    // ++n3; // compile error
}
 
int main()
{
    int n1 = 1, n2 = 2, n3 = 3;
    std::function<void()> bound_f = std::bind(f, n1, std::ref(n2), std::cref(n3));
    n1 = 10;
    n2 = 11;
    n3 = 12;
    std::cout << "Before function: " << n1 << ' ' << n2 << ' ' << n3 << '
';
    bound_f();
    std::cout << "After function: " << n1 << ' ' << n2 << ' ' << n3 << '
';
}

输出：

Before function: 10 11 12
In function: 1 11 12
After function: 10 12 12

http://zh.cppreference.com/w/cpp/utility/functional/ref

#include <thread>
#include <iostream>
using namespace std;


void func1(int& a)
{
    a++;
}

void func2(int a)
{
    a++;
}

int main()
{
    int a = 42;
    std::thread t1(func1, std::ref(a));
    std::thread t2(func2, a);
    std::thread t3(func2, std::ref(a));
    //std::thread t4(func1, a); 编译错误
    t1.join();
    t2.join();
    t3.join();

    std::cout << a << std::endl; return 0;
}