本文给出引用折叠、万能引用和完美转发的相关代码。需要注意的是万能引用(T &&arg)中匹配的类型T，要么是U，要么是U&&。forward的返回值，要么是不具名左值引用，要么是不具名右值引用。在wrapper中，对forward的调用，要么是forward<U>(U &&arg)，要么是forward<U&>(U &arg)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#include <iostream>
#include <utility>

void some_function(int &x)
{
    std::cout << "Left value reference: " << x << std::endl;
}

void some_function(int &&x)
{
    std::cout << "Right value reference: " << x << std::endl;
}

template <typename T>
constexpr T &&
forward(typename std::remove_reference<T>::type &t) noexcept
{
    if (std::is_lvalue_reference<T>::value)
    {
        std::cout << "forward<U&>(U &t): " << std::endl;
    }
    else if (std::is_rvalue_reference<T>::value)
    {
        std::cout << "forward<U&&>(U &t)" << std::endl;
    }
    else
    {
        std::cout << "forward<U>(U &t)" << std::endl;
    }
    return static_cast<T &&>(t);
}

template <typename T>
constexpr T &&
forward(typename std::remove_reference<T>::type &&t) noexcept
{
    if (std::is_lvalue_reference<T>::value)
    {
        std::cout << "forward<U&>(U &&t)" << std::endl;
    }
    else if (std::is_rvalue_reference<T>::value)
    {
        std::cout << "forward<U&&>(U &&t)" << std::endl;
    }
    else
    {
        std::cout << "forward<U>(U &&t)" << std::endl;
    }
    static_assert(!std::is_lvalue_reference<T>::value,
                  "std::forward must not be used to convert an rvalue to an lvalue");
    return static_cast<T &&>(t);
}

template <typename T>
void wrapper(T &&arg)
{
    // 这里的T&&会折叠为左值引用或右值引用，取决于传递的参数类型
    // static_assert(!std::is_rvalue_reference<T>::value);

    if (std::is_lvalue_reference<T>::value)
    {
        std::cout << "wrapper<U&>(U &arg)" << std::endl;
    }
    else if (std::is_rvalue_reference<T>::value)
    {
        std::cout << "wrapper<U&&>(U &&arg)" << std::endl;
    }
    else // !std::is_reference<T>::value
    {
        std::cout << "wrapper<U>(U &&arg)" << std::endl;
    }

    some_function(forward<T>(arg)); // 完美转发
}

void test0() {
    forward<int>(1);
    // forward<int&>(1);
    forward<int&&>(1);
    printf("\n");
    
    int a = 2;
    forward<int>(a);
    forward<int&>(a);
    forward<int&&>(a);
    printf("\n");

    int b = 3;
    forward<int>(static_cast<int&>(b));
    forward<int&>(static_cast<int&>(b));
    forward<int&&>(static_cast<int&>(b));
    printf("\n");

    b = 4;
    int &c = b;
    forward<int>(c);
    forward<int&>(c);
    forward<int&&>(c);
    printf("\n");

    forward<int>(static_cast<int&&>(5));
    // forward<int&>(static_cast<int&&>(5));
    forward<int&&>(static_cast<int&&>(5));
    printf("\n");

    int &&d = 6;
    forward<int>(d);
    forward<int&>(d);
    forward<int&&>(d);
}

void test1() {
    wrapper(1);
    printf("\n");

    int a = 2;
    wrapper(a);
    printf("\n");

    a = 3;
    wrapper(static_cast<int &>(a));
    printf("\n");

    a = 4;
    int &b = a;
    wrapper(b);
    printf("\n");

    wrapper(std::move(5));
    printf("\n");

    int &&c = 6;
    wrapper(c);
}

int main()
{
    test0();
    test1();
}