调用VBO构造函数出现参数列表不匹配错误的解决方法

你遇到的错误核心是参数类型不匹配：
VBO的构造函数要求第二个参数是std::vector<std::variant<Vertex, uint32_t>>，但你传入的是std::vector<Vertex>或std::vector<uint32_t>——这两种vector的元素类型完全不同，编译器无法自动将单一类型的vector转换为variant的vector，因此报构造函数不匹配错误。你之前尝试的继承修改、类关系调整都未触及这个核心问题，所以无效。

解决方案 #

方案1：手动构造符合要求的variant vector #

调用VBO时，将传入的vector元素逐个包装成std::variant<Vertex, uint32_t>，再生成新的vector：

VkGraphicsPipeline(VulkanAPI VkApplication, std::vector<Vertex> vertices) : VkGraphicsUnit(VkApplication) {
    std::vector<std::variant<Vertex, uint32_t>> variant_content;
    variant_content.reserve(vertices.size());
    for (const auto& v : vertices) {
        variant_content.emplace_back(v);
    }
    VBO(this, variant_content);
    ...; 
}

如果是uint32_t类型的vector，同理处理：

VkGraphicsPipeline(VkGraphicsUnit* pVkGPU, std::vector<uint32_t> indices) {
    std::vector<std::variant<Vertex, uint32_t>> variant_content;
    variant_content.reserve(indices.size());
    for (const auto& idx : indices) {
        variant_content.emplace_back(idx);
    }
    VBO(pVkGPU, variant_content); 
}

方案2：给VBO添加重载构造函数（更友好） #

直接给VBO类添加两个重载构造函数，分别接受std::vector<Vertex>和std::vector<uint32_t>，内部自动转换为variant的vector，调用时无需手动处理：

struct VBO {
    VkBuffer buffer;
    VkDeviceMemory memory;

    // 原构造函数
    VBO(VkGraphicsUnit* pVkGPU, std::vector<std::variant<Vertex, uint32_t>> content) {
        ...; 
    }

    // 重载：处理Vertex类型的vector
    VBO(VkGraphicsUnit* pVkGPU, const std::vector<Vertex>& vertices) 
        : VBO(pVkGPU, convert_to_variant(vertices)) {}

    // 重载：处理uint32_t类型的vector
    VBO(VkGraphicsUnit* pVkGPU, const std::vector<uint32_t>& indices) 
        : VBO(pVkGPU, convert_to_variant(indices)) {}

private:
    // 辅助转换函数
    static std::vector<std::variant<Vertex, uint32_t>> convert_to_variant(const std::vector<Vertex>& vec) {
        std::vector<std::variant<Vertex, uint32_t>> res;
        res.reserve(vec.size());
        for (const auto& v : vec) res.emplace_back(v);
        return res;
    }

    static std::vector<std::variant<Vertex, uint32_t>> convert_to_variant(const std::vector<uint32_t>& vec) {
        std::vector<std::variant<Vertex, uint32_t>> res;
        res.reserve(vec.size());
        for (const auto& idx : vec) res.emplace_back(idx);
        return res;
    }
};

这种方式下你原来的调用代码无需修改，直接传入std::vector<Vertex>或std::vector<uint32_t>即可。

方案3：模板构造函数（更通用） #

如果需要支持更多兼容类型，可以将VBO的构造函数改为模板形式：

struct VBO {
    VkBuffer buffer;
    VkDeviceMemory memory;

    // 模板构造函数，限定仅接受Vertex或uint32_t类型的vector
    template<typename T>
    requires (std::is_same_v<T, Vertex> || std::is_same_v<T, uint32_t>)
    VBO(VkGraphicsUnit* pVkGPU, const std::vector<T>& content) {
        std::vector<std::variant<Vertex, uint32_t>> variant_content;
        variant_content.reserve(content.size());
        for (const auto& elem : content) {
            variant_content.emplace_back(elem);
        }
        // 原构造函数的逻辑放在此处，或调用原构造函数
        ...; 
    }

    // 保留原构造函数以兼容旧代码
    VBO(VkGraphicsUnit* pVkGPU, std::vector<std::variant<Vertex, uint32_t>> content) {
        ...; 
    }
};

该方案无需编写多个重载函数，只要是Vertex或uint32_t类型的vector都能直接传入。

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