Stdref and stdcref

std::ref and std::cref

1 std::ref and std::cref

c++11 Introduction in std::ref Used to get a reference to a variable , This introduction is to solve some parameter transfer problems .

• std::ref Used to wrap values passed by reference .
• std::cref For packing according to const Value passed by reference .

We know C++ There are references in , why C++11 There is another one introduced in std::ref Well ？ It's mainly about functional programming （ Such as std::bind） When use , It's a direct copy of the parameters , Not references .

#include <iostream>
#include <functional>
void f(int &n1, int &n2, const int &n3)
{
    std::cout << "In function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
    ++n1; // increments the copy of n1 stored in the function object
    ++n2; // increments the main()'s n2
    // ++n3; // compile error
}

int main(int, char **)
{
    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 << '\n';
    bound_f();
    std::cout << "After function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
}

Output ：

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

The above code is executing std::bind after , In function f() in n1 The value of is still 1,n2 and n3 Changed to the modified value , explain std::bind A copy of the parameter is used instead of a reference , Therefore, it must be shown that std::ref For reference binding . Why exactly std::bind Do not use references , There may indeed be some needs , bring C++11 Our designers believe that copy should be adopted by default , If the user has a demand , add std::ref that will do .

Allied , also std::thread It must also be explicitly passed std::ref To bind references and pass parameters , otherwise , The reference declaration of formal parameters is invalid .

void foo(string &msg)
{
    msg = "i am foo string";
}

    string msg = "hello world";
    thread *th = new thread(foo, std::ref(msg));
    th->join();
    std::cout << "msg:" << msg << endl;

2 std::bind

Can be std::bind Function as a general function adapter , It takes a callable object , Generate a new callable object to fit the parameter list of the original object .std::bind Bind the callable object with its parameters , The result after binding can be used std::function preservation .

2.1 Bind ordinary functions

#include <functional>
void foo(string &msg, int i)
{
    msg = "i am foo:" + msg + to_string(i);
}

int main(int, char **)
{
    auto f = std::bind(foo, std::placeholders::_1, 100);

    string msg;
    f(std::ref(msg));
    std::cout << msg << endl; // i am foo:100
}

You can bind parameters when Binding , You can also occupy a seat first , Pass in parameters when executing .

2.2 Bind a member function

typedef struct
{
    /* data */
    void foo(string &msg, int i)
    {
        msg = "i am foo:" + msg + to_string(i);
    }
} bar;

int main(int, char **)
{
    bar b;
    auto f = std::bind(bar::foo, &b, std::placeholders::_1, 100);

    string msg;
    f(std::ref(msg));
    std::cout << msg << endl; // i am foo:100
}

For member functions , When Binding ：

• The specified method must be displayed bar::foo.
• You must know which object this method belongs to , So the second parameter is the address of the object &b

2.3 std::thread

In the use of std::thread When , We also need to pay attention to the same problem .

typedef struct
{
    /* data */
    void foo(string &msg, int i)
    {
        msg = "i am foo:" + msg + to_string(i);
    }
} bar;

int main(int, char **)
{
    string msg;
    bar b;
    thread th(bar::foo, &b, std::ref(msg), 100);
    th.join();
    std::cout << msg << endl; // i am foo:100
}