C++中如何在函数内多次使用万能引用？

问题背景 #

当使用万能引用（T&&）接收右值（临时对象），且函数内部需要多次将该参数传递给带有右值引用重载的目标函数时，直接使用std::forward会导致右值在首次转发后被移动（move），后续调用会访问已失效的对象（如示例中grade2的Charlie拿到空游戏名）。需要找到既保留右值优化，又能安全多次使用参数的标准方案。

示例代码 #

#include <iostream>
#include <vector>
#include <type_traits>
using namespace std;

struct Game {
    Game(const std::string& n) : name(n) {}
    Game(std::string&& n) : name(std::move(n)) {}
    std::string name;
};

struct Student {
    Student(const string& n) : name(n){}
    Student(string&& n) : name(std::move(n)) {}

    void play(const std::string& game) {
        cout << name << " plays |" << game << "| (L)"<< endl;
        games.emplace_back(game);
    }
    void play(std::string&& game) {
        cout << name << " plays |" << game << "| (R)"<< endl;
        games.emplace_back(std::move(game));
    }
    void play(const Game& game) {
        cout << name << " plays |" << game.name << "| (L)"<< endl;
        games.emplace_back(game);
    }
    void play(Game&& game) {
        cout << name << " plays |" << game.name << "| (R)"<< endl;
        games.emplace_back(std::move(game));
    }
    std::string name;
    std::vector<Game> games;
};

struct Class {
    Class(const vector<string>& names) {
        for (auto name : names) {
            students.emplace_back(std::move(name));
        }
    }
    
    template <typename G>
    void play_by_first(G&& game) {
        if (students.size() == 0) return;
        students[0].play(std::forward<G>(game));
    }

    // 需要修改的核心函数
    template <typename G>
    void play(G&& game) {
        for (auto& student : students) {
            student.play(std::forward<G>(game)); // 原代码问题所在
        }
    }
    vector<Student> students;
};

int main() {
    Class grade1({"alice"});
    grade1.play("football");
    grade1.play(Game("basketball"));

    cout << endl;
    Class grade2({"bob", "Charlie"});
    grade2.play(std::string{"football"});
    grade2.play(Game("basketball"));
}

标准解决方案 #

核心思路：区分参数的值类别，对左值直接转发，对右值先复制后为每次调用生成独立的可移动对象。

方案1：C++17及以上（使用if constexpr区分值类别） #

修改Class::play函数如下：

template <typename G>
void play(G&& game) {
    using DecayedG = std::decay_t<G>;
    if constexpr (std::is_rvalue_reference_v<G&&>) {
        // 处理右值：先复制原临时对象到本地，避免提前销毁
        DecayedG local_copy = std::forward<G>(game);
        // 为每个学生生成独立的临时对象，移动进学生的游戏列表
        for (auto& student : students) {
            student.play(DecayedG(local_copy));
        }
    } else {
        // 处理左值：直接转发左值引用，所有学生共享原对象的引用
        for (auto& student : students) {
            student.play(std::forward<G>(game));
        }
    }
}

• 右值处理：先将临时对象复制到本地local_copy，之后每次为学生构造新的临时对象（复制local_copy），并通过右值引用转发给Student::play，既利用了移动语义优化，又保证每个学生拿到有效对象。
• 左值处理：直接转发左值引用，调用const&重载，无需复制。

方案2：C++23（使用std::forward_like简化） #

C++23新增的std::forward_like可以根据原始参数的值类别转发表达式，但本质仍需为右值生成独立副本：

#include <utility> // 引入std::forward_like

template <typename G>
void play(G&& game) {
    using DecayedG = std::decay_t<G>;
    if constexpr (std::is_rvalue_reference_v<G&&>) {
        DecayedG local_copy = std::forward<G>(game);
        for (auto& student : students) {
            // 根据原始参数的值类别转发副本
            student.play(std::forward_like<G>(DecayedG(local_copy)));
        }
    } else {
        for (auto& student : students) {
            student.play(std::forward<G>(game));
        }
    }
}

方案3：拆分重载（放弃万能引用，更直观） #

直接为左值和右值分别写重载函数，避免模板分支：

// 左值引用重载：传递原对象的const引用
template <typename G>
void play(const G& game) {
    for (auto& student : students) {
        student.play(game);
    }
}

// 右值引用重载：复制后为每个学生生成可移动对象
template <typename G>
void play(G&& game) {
    using DecayedG = std::decay_t<G>;
    DecayedG local_copy = std::forward<G>(game);
    for (auto& student : students) {
        student.play(DecayedG(local_copy));
    }
}

关键说明 #

• 右值的多次转发必然需要复制：因为右值只能被移动一次，若每个学生都需要拥有独立的对象，复制是不可避免的代价（除非设计为共享对象，但不符合示例中每个学生games容器存储独立对象的需求）。
• 万能引用的优势：方案1和2保留了万能引用的灵活性，同时通过编译期分支处理不同值类别，兼顾性能和安全性。

内容的提问来源于stack exchange，提问作者doraemon