C++中std::forward的实现示例

#include <iostream>

// 目标函数：分别处理左值和右值
void process(int& x) { std::cout << "处理左值: " << x << std::endl; }
void process(int&& x) { std::cout << "处理右值: " << x << std::endl; }

// 转发函数：尝试传递参数
template <typename T>
void forward_param(T param) {
    process(param);  // 参数属性已丢失
}

int main() {
    int a = 10;
    forward_param(a);  // 传入左值，实际调用process(int&)
    forward_param(20); // 传入右值，却调用process(int&)（错误）
    return 0;
}

// 重载1：处理左值输入（参数为左值引用）
template <typename T>
T&& forward(typename std::remove_reference<T>::type& t) noexcept {
    return static_cast<T&&>(t);
}

// 重载2：处理右值输入（参数为右值引用）
template <typename T>
T&& forward(typename std::remove_reference<T>::type&& t) noexcept {
    static_assert(!std::is_lvalue_reference<T>::value, "错误：不能将右值转发为左值");
    return static_cast<T&&>(t);
}

#include <iostream>
#include <utility>

void process(int& x) { std::cout << "处理左值: " << x << std::endl; }
void process(int&& x) { std::cout << "处理右值: " << x << std::endl; }

// 完美转发函数：万能引用 + std::forward
template <typename T>
void perfect_forward(T&& param) {  // T&&为万能引用
    process(std::forward<T>(param));  // 根据T的类型转发
}

int main() {
    int a = 10;
    perfect_forward(a);          // 左值→转发为左值
    perfect_forward(20);         // 右值→转发为右值
    perfect_forward(std::move(a)); // 右值→转发为右值
    return 0;
}

#include <iostream>
#include <string>
#include <utility>

class Person {
private:
    std::string name_;
    int age_;
public:
    Person(std::string name, int age) 
        : name_(std::move(name)), age_(age) {
        std::cout << "构造Person：" << name_ << ", " << age_ << std::endl;
    }
};

// 工厂函数：完美转发参数到构造函数
template <typename... Args>
Person create_person(Args&&... args) {
    return Person(std::forward<Args>(args)...);  // 包展开+完美转发
}

int main() {
    std::string name = "Alice";
    create_person(name, 30);          // 转发左值
    create_person("Bob", 25);         // 转发右值
    create_person(std::move(name), 35); // 转发移动后的左值
    return 0;
}

#include <iostream>
#include <utility>

// 内部处理函数
void core_operation(int& x) { x *= 2; }
void core_operation(int&& x) { std::cout << "处理临时值：" << x << std::endl; }

// 包装函数：添加日志并转发参数
template <typename T>
void wrapped_operation(T&& x) {
    std::cout << "=== 开始操作 ===" << std::endl;
    core_operation(std::forward<T>(x));  // 完美转发
    std::cout << "=== 结束操作 ===" << std::endl;
}

int main() {
    int a = 10;
    wrapped_operation(a);  // 转发左值，修改a
    std::cout << "a = " << a << std::endl;  // 输出20
    
    wrapped_operation(20);  // 转发右值，处理临时值
    return 0;
}