如何防止资源管理器返回的资源引用被复制？

你提到自己有一个模板资源管理器类，需要获取其中重量级资源的引用，但这些资源是他人定义的可复制类，而你绝对不想无意中复制这些资源（毕竟重量级对象的复制成本太高了），同时又没法给资源定义统一基类。先把你给出的示例代码补全，能更清楚地看到问题所在：

#include <iostream>

// 第三方定义的可复制类
class Copyable {
public:
    Copyable() { std::cout << "Copyable constructed\n"; }
    Copyable(const Copyable&) { std::cout << "Copyable copied\n"; } // 拷贝构造会触发
    ~Copyable() { std::cout << "Copyable destroyed\n"; }
    
    void do_something() { std::cout << "Doing something with Copyable\n"; }
};

// 你的模板资源管理器
template<typename Resource>
class ResourceManager {
private:
    Resource resource_; // 管理器持有资源实例
public:
    Resource get_resource() {
        return resource_; // 这里返回值类型，会触发资源拷贝！
    }
};

int main() {
    ResourceManager<Copyable> manager;
    auto res = manager.get_resource(); // 意外触发了拷贝构造
    res.do_something();
    return 0;
}

这段代码的核心问题就是get_resource()返回的是值类型，会强制调用资源的拷贝构造函数，这正是你要避免的情况。下面给你几个适配任意第三方资源类的优雅解决方案：

1. 返回左值引用（最直接的方案） #

修改资源管理器的get_resource()方法，直接返回资源的左值引用，这样就能拿到管理器内部资源的直接引用，完全不会触发复制：

template<typename Resource>
class ResourceManager {
private:
    Resource resource_;
public:
    // 普通场景返回非const引用
    Resource& get_resource() {
        return resource_;
    }

    // 为const场景提供const引用（可选但很实用）
    const Resource& get_resource() const {
        return resource_;
    }
};

// 使用方式
int main() {
    ResourceManager<Copyable> manager;
    Copyable& res = manager.get_resource(); // 无任何拷贝
    res.do_something();

    // const场景下的使用
    const auto& const_manager = manager;
    const Copyable& const_res = const_manager.get_resource();
    const_res.do_something();
    return 0;
}

这个方案的好处是简单粗暴零开销，完全贴合你的需求。唯一要注意的是：必须保证资源管理器的生命周期长于你使用引用的周期，避免出现悬垂引用。

2. 使用std::reference_wrapper（适配需要存储引用的场景） #

如果你需要把资源引用存入容器，或者放到其他要求可复制/可移动类型的地方，std::reference_wrapper是绝佳选择——它把引用包装成一个可复制的对象，但底层依然是引用语义：

#include <functional> // 引入std::reference_wrapper

template<typename Resource>
class ResourceManager {
private:
    Resource resource_;
public:
    std::reference_wrapper<Resource> get_resource() {
        return std::ref(resource_);
    }

    std::reference_wrapper<const Resource> get_resource() const {
        return std::cref(resource_);
    }
};

// 使用方式
int main() {
    ResourceManager<Copyable> manager;
    auto res_wrap = manager.get_resource(); // 包装的引用，无拷贝
    Copyable& res = res_wrap.get(); // 提取出原始引用
    res.do_something();

    // 可以直接存入容器
    std::vector<std::reference_wrapper<Copyable>> res_list;
    res_list.push_back(manager.get_resource());
    res_list[0].get().do_something();
    return 0;
}

3. 返回指针（灵活但需注意空指针） #

如果你想更明确地表达“这是指向内部资源的句柄”，或者需要处理资源可能不存在的场景，返回指针也是一个选项：

template<typename Resource>
class ResourceManager {
private:
    Resource resource_;
public:
    Resource* get_resource() {
        return &resource_;
    }

    const Resource* get_resource() const {
        return &resource_;
    }
};

// 使用方式
int main() {
    ResourceManager<Copyable> manager;
    Copyable* res = manager.get_resource(); // 无拷贝
    if (res) { // 可以做空指针检查（这里实际不会为空，但好习惯可以保留）
        res->do_something();
    }
    return 0;
}

最适合你场景的是返回左值引用的方案，它简单、无额外开销，完美满足你获取资源引用且不复制的需求。如果需要把引用存入容器，就用std::reference_wrapper。这两种方案都不需要修改第三方资源类，完全适配你的模板资源管理器。

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