第16课右值引用（3）_std::forward与完美转发

1. std::forward原型

template <typename T>

T&& forward(typename std::remove_reference<T>::type& param) //左值引用版本

{

    return static_cast<T&&>(param);

}

template <typename T>

T&& forward(typename std::remove_reference<T>::type&& param)  //右值引用版本

{

    //param被右值初始化时，T应为右值引用类型，如果T被绑定为左值引用则报错。

    static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"

    " substituting _Tp is an lvalue reference type"); 

    return static_cast<T&&>(param);

}

//其中remove_reference的实现如下

//1. 特化版本（一般的类）

template <typename T>

struct remove_reference

{

    typedef T type;

};

//2. 左值引用版本

template <typename T>

struct remove_reference<T&>

{

    typedef T type;

};

//3. 右值引用版本

template <typename T>

struct remove_reference<T&&>

{

    typedef T type;

};

2. 完美转发（Perfect Forwarding）

（1）完美转发：是指在函数模板中，完全依照模板的参数类型（即保持实参的左值、右值特性），将实参传递给函数模板中调用的另外一个函数。

（2）原理分析

class Widget{};

//完美转发

template<typename T>

void func(T&& fparam) //fparam是个Universal引用

{

    doSomething(std::forward<T>(fparam));

}

//1. 假设传入func是一个左值的Widget对象， T被推导为Widget&，则forward如下：

Widget& && forward(typename std::remove_reference<Widget&>::type& param)

{

    return static_cast<Widget& &&>(param);

}

//==>引用折叠折后

Widget& forward(Widget& param)

{

    return static_cast<Widget&>(param);

}

//2. 假设传入func是一个右值的Widget对象， T被推导为Wiget，则forward如下：

Widget&& forward(typename std::remove_reference<Widget>::type& param)

{

    return static_cast<Widget&&>(param);

}

（3）std::forward和std::move的联系和区别

　　①std::move是无条件转换，不管它的参数是左值还是右值，都会被强制转换成右值。就其本身而言，它没有move任何东西。

　　②std::forward是有条件转换。只有在它的参数绑定到一个右值时，它才转换它的参数到一个右值。当参数绑定到左值时，转换后仍为左值。

　　③对右值引用使用std::move，对universal引用则使用std::forward

　　④如果局部变量有资格进行RVO优化，不要把std::move或std::forward用在这些局部变量中

　　⑤std::move和std::forward在运行期都没有做任何事情。

【编程实验】不完美转发和完美转发

#include <iostream>

//#include <utility> //for std::forward

using namespace std;

void print(const int& t)

{

    cout <<"lvalue" << endl;

}

void print(int&& t)

{

    cout <<"rvalue" << endl;

}

template<typename T>

void Test(T&& v) //v是Universal引用

{

    //不完美转发

    print(v);  //v具有变量，本身是左值，调用print(int& t)

    //完美转发

    print(std::forward<T>(v)); //按v被初始化时的类型转发（左值或右值）

    //强制将v转为右值

    print(std::move(v)); //将v强制转为右值，调用print(int&& t)

}

int main()

{

    cout <<"========Test(1)========" << endl;

    Test(); //传入右值

    int x = ;

    cout <<"========Test(x)========" << endl;

    Test(x); //传入左值

    cout <<"=====Test(std::forward<int>(1)===" << endl;

    Test(std::forward<int>()); //T为int，以右值方式转发1

    //Test(std::forward<int&>(1)); //T为int&，需转入左值

    cout <<"=====Test(std::forward<int>(x))===" << endl;

    Test(std::forward<int>(x)); //T为int，以右值方式转发x

    cout <<"=====Test(std::forward<int&>(x))===" << endl;

    Test(std::forward<int&>(x)); //T为int，以左值方式转发x

    return ;

}

/*输出结果

e:\Study\C++11\16>g++ -std=c++11 test2.cpp

e:\Study\C++11\16>a.exe

========Test(1)========

lvalue

rvalue

rvalue

========Test(x)========

lvalue

lvalue

rvalue

=====Test(std::forward<int>(1)===

lvalue

rvalue

rvalue

=====Test(std::forward<int>(x))===

lvalue

rvalue

rvalue

=====Test(std::forward<int&>(x))===

lvalue

lvalue

rvalue

*/

3.万能的函数包装器

（1）利用std::forward和可变参数模板实现

　　①可将带返回值、不带返回值、带参和不带参的函数委托万能的函数包装器执行。

　　②Args&&为Universal引用，因为这里的参数可能被左值或右值初始化。Funciont&&也为Universal引用，如被lambda表达式初始化。

　　③利用std::forward将参数正确地（保持参数的左、右值属性）转发给原函数

【编程实验】万能的函数包装器

#include <iostream>

using namespace std;

//万能的函数包装器

//可将带返回值、不带返回值、带参和不带参的函数委托万能的函数包装器执行

//注意：Args&&表示Universal引用，因为这里的参数可能被左值或右值初始化

//      Funciont&&也为Universal引用，如被lambda表达式初始化

template<typename Function, class...Args>

auto FuncWrapper(Function&& func, Args&& ...args)->decltype(func(std::forward<Args>(args)...))

{

    return func(std::forward<Args>(args)...);

}

void test0()

{

    cout << "void test0()" << endl;

}

int test1()

{

    return ;

}

int test2(int x)

{

    return x;

}

string test3(string s1, string s2)

{

    return s1 + s2;

}

int main()

{

    FuncWrapper(test0);

    cout << "int test1(): ";

    cout << FuncWrapper(test1) << endl;

    cout << "int test2(int x): " ;

    cout << FuncWrapper(test2, ) << endl;

    cout << "string test3(string s1, string s2): ";

    cout << FuncWrapper(test3, "aa", "bb") << endl;

    cout << "[](int x, int y){return x + y;}: ";

    cout << FuncWrapper([](int x, int y){return x + y;}, ,  ) << endl;

    return ;

}

/*输出结果：

e:\Study\C++11\16>g++ -std=c++11 test3.cpp

e:\Study\C++11\16>a.exe

void test0()

int test1(): 1

int test2(int x): 1

string test3(string s1, string s2): aabb

[](int x, int y){return x + y}: 3

*/

（2）emplace_back减少内存拷贝和移动

　　①emplace_back的实现原理类似于“万能函数包装器”，将参数std::forward转发给元素类的构造函数。实现上，首先为该元素开辟内存空间，然后在这片空间中调用placement new进行初始化，这相当于“就地”(在元素所在内存空间)调用元素对象的构造函数。

　　②而push_back会先将参数转为相应的元素类型，这需要调用一次构造函数，再将这个临时对象拷贝构造给容器内的元素对象，所以共需要一次构造和一次拷贝构造。从效率上看不如emplace_back，因为后者只需要一次调用一次构造即可。

　　③一般传入emplace_back的是构造函数所对应的参数(也只有这样传参才能节省一次拷贝构造)，所以要求对象有相应的构造函数，如果没有对应的构造函数，则只能用push_back，否则编译会报错。如emplace_back(int, int)，则要求元素对象需要有带两个int型的构造函数。

【编程实验】emplace_back减少内存拷贝和移动

#include <iostream>

#include <vector>

using namespace std;

class Test

{

    int m_a;

public:

    static int m_count;

    Test(int a) : m_a(a)

    {

        cout <<"Test(int a)" << endl;

    }

    Test(const Test& t) : m_a(t.m_a)

    {

        ++m_count;

        cout << "Test(const Test& t)" << endl;

    }

    Test& operator=(const Test& t)

    {

        this->m_a = t.m_a;

        return *this;

    }

};

int Test::m_count = ;

int main()

{

    //创建10个值为1的元素

    Test::m_count = ;

    vector<Test> vec(, ); //首先将1转为Test(1)，会调用1次Test(int a)。然后，利用Test(1)去拷贝构造10个元素，所以

                             //调用10次拷贝构造。

    cout << "vec.capacity():" << vec.capacity() << ", "; //

    cout << "vec.size():" << vec.size() <<  endl;        //10,空间己满

    Test::m_count = ;

    vec.push_back(Test()); //由于capacity空间己满。首先调用Test(1)，然后再push_back中再拷贝

                            //构造10个元素（而不是1个，为了效率），所以调用10次拷贝构造

    cout << "vec.capacity():" << vec.capacity() << ", ";  //

    cout << "vec.size():" << vec.size() <<  endl;         //11,空间未满

    Test::m_count = ;

    vec.push_back();  //先调用Test(1)，然后调用1次拷贝构造

    cout << "vec.capacity():" << vec.capacity() << ", "; //

    cout << "vec.size():" << vec.size() <<  endl;         //12,空间未满

    Test::m_count = ;

    vec.emplace_back(); //由于空间未满，直接在第12个元素位置调用placement new初始化那段空间

                         //所以就会调用构造函数，节省了调用拷贝构造的开销

    cout << "vec.capacity():" << vec.capacity() << ", "; //

    cout << "vec.size():" << vec.size() <<  endl;        //13,空间未满

    Test::m_count = ;

    vec.emplace_back(Test()); //先调用Test(1)，再调用拷贝构造（注意与vec.emplace_back(1)之间差异）

    cout << "vec.capacity():" << vec.capacity() << ", "; //

    cout << "vec.size():" << vec.size() <<  endl;        //14,空间未满

    return ;

}

/*输出结果

e:\Study\C++11\16>g++ -std=c++11 test4.cpp

e:\Study\C++11\16>a.exe

Test(int a)

...  //中间省略了调用10次Test(const Test& t)

vec.capacity():10, vec.size():10

Test(int a)

...  //中间省略了调用10次Test(const Test& t)

vec.capacity():20, vec.size():11

Test(int a)

Test(const Test& t)

vec.capacity():20, vec.size():12

Test(int a)

vec.capacity():20, vec.size():13

Test(int a)

Test(const Test& t)

vec.capacity():20, vec.size():14

*/

巴特西

第16课右值引用（3）_std::forward与完美转发

最新文章

热门文章

巴特西

第16课 右值引用（3）_std::forward与完美转发

最新文章

热门文章

第16课右值引用（3）_std::forward与完美转发