VkShader存入std::vector致Vulkan着色器加载失败的原因与解决

核心原因是VkShader类的资源所有权管理错误：

• VkShader的构造函数创建VkShaderModule，析构函数销毁该句柄，但未禁用默认的拷贝构造/赋值运算符。
• 当std::vector存储VkShader对象时，vector的扩容、插入操作会触发默认拷贝，生成多个持有同一VkShaderModule句柄的VkShader实例。
• 多个实例共享同一底层资源引发两种错误：
  1. 若某个实例先析构（比如vector扩容时销毁旧元素），剩余实例的句柄会变成无效值，后续使用（如管线创建）就会触发"VkShaderModule无效"的验证层错误。
  2. 程序退出时所有实例析构，同一句柄被多次调用vkDestroyShaderModule，触发"重复销毁"的错误。

针对资源所有权问题，提供三种可行方案：

方案1：禁用拷贝，实现移动语义 #

让VkShader类独占资源所有权，禁用拷贝行为，通过移动语义转移资源，避免多实例共享句柄。

class VkShader {
private:
    VkShaderModule m_module = VK_NULL_HANDLE;
    VkDevice m_device;

public:
    // 构造函数：创建ShaderModule
    VkShader(VkDevice device, const std::vector<char>& shaderCode)
        : m_device(device) {
        VkShaderModuleCreateInfo createInfo{};
        createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
        createInfo.codeSize = shaderCode.size();
        createInfo.pCode = reinterpret_cast<const uint32_t*>(shaderCode.data());

        if (vkCreateShaderModule(m_device, &createInfo, nullptr, &m_module) != VK_SUCCESS) {
            throw std::runtime_error("Failed to create shader module");
        }
    }

    // 禁用拷贝构造与赋值
    VkShader(const VkShader&) = delete;
    VkShader& operator=(const VkShader&) = delete;

    // 移动构造：转移资源所有权
    VkShader(VkShader&& other) noexcept
        : m_module(other.m_module), m_device(other.m_device) {
        other.m_module = VK_NULL_HANDLE; // 原对象放弃所有权
    }

    // 移动赋值
    VkShader& operator=(VkShader&& other) noexcept {
        if (this != &other) {
            // 销毁当前持有的资源
            if (m_module != VK_NULL_HANDLE) {
                vkDestroyShaderModule(m_device, m_module, nullptr);
            }
            // 转移所有权
            m_module = other.m_module;
            m_device = other.m_device;
            other.m_module = VK_NULL_HANDLE;
        }
        return *this;
    }

    // 析构函数：仅销毁有效句柄
    ~VkShader() {
        if (m_module != VK_NULL_HANDLE) {
            vkDestroyShaderModule(m_device, m_module, nullptr);
        }
    }

    // 获取ShaderModule句柄
    VkShaderModule getModule() const { return m_module; }
};

使用vector时，通过emplace_back直接构造对象，或用std::move转移现有对象：

std::vector<VkShader> shaders;
// 直接在vector中构造，无拷贝
shaders.emplace_back(device, vertex_shader_code);
// 移动现有VkShader对象到vector
VkShader fragment_shader(device, fragment_shader_code);
shaders.push_back(std::move(fragment_shader));

方案2：用智能指针管理所有权 #

通过std::unique_ptr（独占所有权）或std::shared_ptr（共享所有权）包装VkShader，让智能指针自动处理资源的转移和销毁，无需修改VkShader的移动语义（但仍建议禁用拷贝避免误用）。

示例（使用unique_ptr）：

// VkShader类保持原有逻辑，但禁用拷贝
class VkShader {
    // ... 同方案1的构造、析构逻辑
    VkShader(const VkShader&) = delete;
    VkShader& operator=(const VkShader&) = delete;
};

// 存储unique_ptr到vector
std::vector<std::unique_ptr<VkShader>> shaders;
shaders.push_back(std::make_unique<VkShader>(device, vertex_shader_code));
shaders.push_back(std::make_unique<VkShader>(device, fragment_shader_code));

方案3：集中式资源管理（工厂模式） #

创建一个全局/局部的Shader管理器，统一负责所有VkShaderModule的创建与销毁，VkShader类仅持有句柄，不负责资源释放。这种方式适合需要共享着色器模块的场景，避免重复创建相同资源。

class ShaderManager {
private:
    VkDevice m_device;
    std::vector<VkShaderModule> m_modules;

public:
    ShaderManager(VkDevice device) : m_device(device) {}

    // 管理器销毁时统一释放所有ShaderModule
    ~ShaderManager() {
        for (auto module : m_modules) {
            vkDestroyShaderModule(m_device, module, nullptr);
        }
    }

    // 创建ShaderModule并加入管理列表
    VkShaderModule createShader(const std::vector<char>& shaderCode) {
        VkShaderModuleCreateInfo createInfo{};
        createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
        createInfo.codeSize = shaderCode.size();
        createInfo.pCode = reinterpret_cast<const uint32_t*>(shaderCode.data());

        VkShaderModule module;
        if (vkCreateShaderModule(m_device, &createInfo, nullptr, &module) != VK_SUCCESS) {
            throw std::runtime_error("Failed to create shader module");
        }
        m_modules.push_back(module);
        return module;
    }
};

// VkShader仅持有句柄，不负责销毁
class VkShader {
private:
    VkShaderModule m_module;

public:
    VkShader(VkShaderModule module) : m_module(module) {}

    VkShaderModule getModule() const { return m_module; }
};

使用方式：

ShaderManager shader_manager(device);
std::vector<VkShader> shaders;
// 通过管理器创建ShaderModule，VkShader仅持有句柄
shaders.emplace_back(shader_manager.createShader(vertex_shader_code));
shaders.emplace_back(shader_manager.createShader(fragment_shader_code));

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