如何处理RAII大对象的昂贵复制？以OpenGL纹理封装为例

针对你遇到的RAII对象（比如OpenGL纹理、大像素缓冲区）复制开销过高的问题，有几个实用的替代方案，既保留RAII的资源管理优势，又避免不必要的深拷贝：

1. 禁用拷贝，改用移动语义 #

如果你的场景中不需要真正复制对象，只是需要转移资源所有权，直接禁用拷贝构造和赋值运算符，同时实现移动构造和移动赋值。这样对象转移时只会拷贝内部的指针/资源句柄，不会复制底层的大内存块。

修改后的Image类示例：

#include <vector>
#include <cstdint>

class Image {
public:
    // 默认构造
    Image() = default;

    // 禁用拷贝构造和赋值
    Image(const Image& other) = delete;
    Image& operator=(const Image& rhs) = delete;

    // 移动构造：转移other的资源
    Image(Image&& other) noexcept : pixels(std::move(other.pixels)) {}

    // 移动赋值：转移rhs的资源
    Image& operator=(Image&& rhs) noexcept {
        if (this != &rhs) {
            pixels = std::move(rhs.pixels);
        }
        return *this;
    }

    void push_pixel(uint8_t pixeldata) {
        pixels.push_back(pixeldata);
    }

private:
    std::vector<uint8_t> pixels; 
};

使用时通过std::move转移所有权：

int main(int argc, char** argv) {
    Image myimage;
    for (uint32_t i = 0; i < 1000000; i++) {
        myimage.push_pixel(0);
    }
    // 转移所有权，无深拷贝开销
    Image newimage = std::move(myimage);
    // 此时myimage的pixels已为空，资源归newimage所有

    return 0;
}

对于OpenGL纹理，移动语义同样适用：把纹理ID的所有权转移给新对象，旧对象不再持有有效纹理ID，避免重复创建GPU资源。

2. 使用共享所有权（引用计数） #

如果需要多个对象共享同一份资源（比如多个地方使用同一个OpenGL纹理），可以用std::shared_ptr管理底层资源，这样拷贝对象时只是复制智能指针（引用计数+1），不会复制底层数据或GPU纹理。

示例代码：

#include <vector>
#include <cstdint>
#include <memory>

class Image {
public:
    Image() : pixels(std::make_shared<std::vector<uint8_t>>()) {}

    // 拷贝构造：复制shared_ptr，引用计数+1
    Image(const Image& other) = default;
    Image& operator=(const Image& rhs) = default;

    void push_pixel(uint8_t pixeldata) {
        pixels->push_back(pixeldata);
    }

    // 如果需要修改时不影响其他共享对象，可以实现写时复制（COW）
    void modify_safely(uint32_t index, uint8_t value) {
        // 如果当前shared_ptr不是唯一所有者，拷贝一份数据
        if (!pixels.unique()) {
            pixels = std::make_shared<std::vector<uint8_t>>(*pixels);
        }
        (*pixels)[index] = value;
    }

private:
    std::shared_ptr<std::vector<uint8_t>> pixels; 
};

这种方式下，拷贝Image对象的开销极低，只有几个字节的指针拷贝。如果需要修改数据，写时复制（COW）能保证每个修改的对象拥有独立副本，同时不影响其他只读的共享对象。

对于OpenGL纹理，可以把纹理ID和对应的CPU数据一起放进shared_ptr管理的结构体中，确保GPU资源在最后一个对象销毁时才被释放（调用glDeleteTextures）。

3. 分离资源拥有者与视图 #

如果大部分场景只是需要读取资源，不需要修改或拥有，可以创建一个轻量的视图类，它不持有资源所有权，只是引用拥有者的资源。视图类的拷贝开销几乎为0，同时保留RAII的安全特性（只要拥有者存活，视图就有效）。

示例：

#include <vector>
#include <cstdint>

// 资源拥有者：管理像素数据的生命周期
class Image {
public:
    void push_pixel(uint8_t pixeldata) {
        pixels.push_back(pixeldata);
    }

    // 返回视图
    class View;
    View get_view() { return View(*this); }

private:
    std::vector<uint8_t> pixels; 

    // 视图类：只能通过Image创建，引用像素数据
public:
    class View {
    public:
        uint8_t get_pixel(uint32_t index) const {
            return owner.pixels[index];
        }

        // 视图可以拷贝，只是复制引用
        View(const View&) = default;
        View& operator=(const View&) = default;

    private:
        friend class Image;
        View(Image& img) : owner(img) {}
        Image& owner;
    };
};

使用时：

int main(int argc, char** argv) {
    Image myimage;
    for (uint32_t i = 0; i < 1000000; i++) {
        myimage.push_pixel(0);
    }
    // 创建视图，无拷贝开销
    Image::View img_view = myimage.get_view();
    // 通过视图读取数据
    uint8_t pixel = img_view.get_pixel(0);

    return 0;
}

这种方式适合频繁传递资源引用的场景，只要保证视图的生命周期不超过拥有者即可。

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