第16课 右值引用（3）_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;
};

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);
}

#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(1); //传入右值
    
    int x = 1;
    cout <<"========Test(x)========" << endl;
    Test(x); //传入左值
    
    cout <<"=====Test(std::forward<int>(1)===" << endl;
    Test(std::forward<int>(1)); //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 0;
}
/*输出结果
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
*/

#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 1;
}

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, 1) << 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;}, 1,  2) << endl;
    
    return 0;
}
/*输出结果：
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
*/

#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 = 0;

int main()
{
    //创建10个值为1的元素
    Test::m_count = 0;
    vector<Test> vec(10, 1); //首先将1转为Test(1)，会调用1次Test(int a)。然后，利用Test(1)去拷贝构造10个元素，所以
                             //调用10次拷贝构造。
    cout << "vec.capacity():" << vec.capacity() << ", "; //10
    cout << "vec.size():" << vec.size() <<  endl;        //10,空间己满
    
    Test::m_count = 0;
    vec.push_back(Test(1)); //由于capacity空间己满。首先调用Test(1)，然后再push_back中再拷贝
                            //构造10个元素（而不是1个，为了效率），所以调用10次拷贝构造
    cout << "vec.capacity():" << vec.capacity() << ", ";  //20
    cout << "vec.size():" << vec.size() <<  endl;         //11,空间未满
    
    Test::m_count = 0;
    vec.push_back(1);  //先调用Test(1)，然后调用1次拷贝构造
    cout << "vec.capacity():" << vec.capacity() << ", "; //20
    cout << "vec.size():" << vec.size() <<  endl;         //12,空间未满
    
    Test::m_count = 0;
    vec.emplace_back(1); //由于空间未满，直接在第12个元素位置调用placement new初始化那段空间
                         //所以就会调用构造函数，节省了调用拷贝构造的开销
    cout << "vec.capacity():" << vec.capacity() << ", "; //20
    cout << "vec.size():" << vec.size() <<  endl;        //13,空间未满
    
    Test::m_count = 0;
    vec.emplace_back(Test(1)); //先调用Test(1)，再调用拷贝构造（注意与vec.emplace_back(1)之间差异）
    cout << "vec.capacity():" << vec.capacity() << ", "; //20
    cout << "vec.size():" << vec.size() <<  endl;        //14,空间未满
    
    return 0;
}
/*输出结果
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
*/