已经有了万能引用，为什么还需要完美转发呢？ #

template<typename T>
void foo(T&& arg) {
    // arg 是万能引用，可以绑定到左值或右值
}

int main() {
    int a = 10;
    foo(a);       // T 推导为 int& → arg 类型是 int&（左值引用）
    foo(10);      // T 推导为 int  → arg 类型是 int&&（右值引用）
}

#include <iostream>

template <class T>
void process(T &&t) {
    std::cout << t << " is " << "rvalue\n";
}

template <class T>
void process(T &t) {
    std::cout << t << " is " << "lvalue\n";
}

template<typename T>
void wrapper(T &&t) {
    process(std::forward<T>(t));
}

template<typename T>
void wrapper_common(T &&t) {
    process(t);
}

int main() {
    // 测试右值引用
    wrapper(1); // rvalue
    // 测试左值引用
    int i = 1;
    wrapper(i); // lvalue
    // 测试完美转发将亡值
    wrapper(std::move(i)); // rvalue
    int j = 2;
    // 测试不用完美转发
    wrapper_common(std::move(j)); // lvalue
    return 0;
}

// named-reference.cpp
#include <iostream>
using namespace std;

// A class that contains a memory resource.
class MemoryBlock {
    // TODO: Add resources for the class here.
};

void g(const MemoryBlock&) {
    cout << "In g(const MemoryBlock&)." << endl;
}

void g(MemoryBlock&&) {
    cout << "In g(MemoryBlock&&)." << endl;
}

MemoryBlock&& f(MemoryBlock&& block) {
    g(block);
    return move(block);
}

void F1() {
    g(f(MemoryBlock()));
}

void F2() {
    auto&& t = f(MemoryBlock());
    g(t);
}

int main() {
    F1();
    std::cout << "--- \n";
    F2();
}