C++类构造函数存同类型对象为元组的问题及优化问询

首先，咱们先明确你代码里的核心问题：你的基类endpoint_keys_impl中定义的keys是固定大小的std::tuple<PropertyObject>——只能容纳单个PropertyObject元素。当你传入多个property参数时，构造函数试图生成一个多元素的tuple去初始化单元素tuple，类型完全不匹配，这就是编译报错的根源。

接下来针对你「不想把所有类逐层模板化到data_endpoint」的需求，提供两种可行方案：

方案1：改用std::vector<PropertyObject>（最简洁） #

如果你的业务场景允许用vector替代tuple（比如不需要编译时固定大小、结构化绑定等tuple专属特性），这是最简单的解决方式。vector的类型固定，不管多少元素都能兼容，完全不需要模板化任何上层类：

class endpoint_keys_impl {
public:
    endpoint_keys_impl() = default;
    // 直接用参数包初始化vector
    template<typename ...PO>
    explicit endpoint_keys_impl(PO... properties) : keys({std::move(properties)...}) {}
private:
    std::vector<PropertyObject> keys; // 替换tuple为vector
};

// 子类代码完全不需要修改
struct websocket_endpoint_keys : public endpoint_keys_impl {
    websocket_endpoint_keys() = default;
    template<typename ...PO>
    explicit websocket_endpoint_keys(PO... properties) : endpoint_keys_impl(properties...) {};
};

struct rest_endpoint_keys : public endpoint_keys_impl {
    rest_endpoint_keys() = default;
    template<typename ...PO>
    explicit rest_endpoint_keys(PO... properties) : endpoint_keys_impl(properties...) {};
};

// data_endpoint保持原样，无需模板化
template <typename T>
class data_endpoint {
public:
    data_endpoint(std::string path, rest_endpoint_keys rest_keys, websocket_endpoint_keys websocket_keys) 
        : _internal_rest_keys(std::move(rest_keys)), 
          _internal_websocket_keys(std::move(websocket_keys)), 
          path(std::move(path)) {};
private:
    rest_endpoint_keys _internal_rest_keys;
    websocket_endpoint_keys _internal_websocket_keys;
    std::string path;
};

这样你原来的初始化代码就能正常运行，而且完全满足「不模板化data_endpoint」的要求。

方案2：保留tuple，使用类型擦除（兼容tuple特性） #

如果你必须保留tuple（比如依赖编译时大小检查、结构化绑定等），可以通过类型擦除将不同大小的tuple包装到一个非模板基类中，让上层类无需模板化：

#include <tuple>
#include <memory>
#include <utility>
#include <cstddef>

// 类型擦除的基类，定义统一接口
class endpoint_keys_base {
public:
    virtual ~endpoint_keys_base() = default;
    virtual std::size_t size() const = 0; // 获取元素数量
    virtual const PropertyObject& get(std::size_t index) const = 0; // 只读访问元素
    virtual PropertyObject& get(std::size_t index) = 0; // 可写访问元素
};

// 模板实现类，存储任意大小的PropertyObject tuple
template<typename... Properties>
class endpoint_keys_impl : public endpoint_keys_base {
    // 编译时检查所有参数都是PropertyObject类型
    static_assert((std::is_same_v<Properties, PropertyObject> && ...), "All properties must be PropertyObject");
public:
    explicit endpoint_keys_impl(Properties... properties) : keys(std::make_tuple(std::move(properties)...)) {}
    
    std::size_t size() const override {
        return std::tuple_size_v<decltype(keys)>;
    }
    
    const PropertyObject& get(std::size_t index) const override {
        return get_impl(index, std::index_sequence_for<Properties...>{});
    }
    
    PropertyObject& get(std::size_t index) override {
        return get_impl(index, std::index_sequence_for<Properties...>{});
    }
    
private:
    std::tuple<Properties...> keys;
    
    // 编译时生成索引匹配逻辑，避免运行时循环
    template<std::size_t... Is>
    const PropertyObject& get_impl(std::size_t index, std::index_sequence<Is...>) const {
        return ((index == Is) ? std::get<Is>(keys) : ...);
    }
    
    template<std::size_t... Is>
    PropertyObject& get_impl(std::size_t index, std::index_sequence<Is...>) {
        return ((index == Is) ? std::get<Is>(keys) : ...);
    }
};

// 子类改为持有类型擦除的智能指针，无需模板化
struct websocket_endpoint_keys {
    websocket_endpoint_keys() = default;
    template<typename... PO>
    explicit websocket_endpoint_keys(PO... properties) 
        : impl(std::make_unique<endpoint_keys_impl<PO...>>(std::move(properties)...)) {}
    
    std::unique_ptr<endpoint_keys_base> impl;
};

struct rest_endpoint_keys {
    rest_endpoint_keys() = default;
    template<typename... PO>
    explicit rest_endpoint_keys(PO... properties) 
        : impl(std::make_unique<endpoint_keys_impl<PO...>>(std::move(properties)...)) {}
    
    std::unique_ptr<endpoint_keys_base> impl;
};

// data_endpoint保持原样，无需模板化
template <typename T>
class data_endpoint {
public:
    data_endpoint(std::string path, rest_endpoint_keys rest_keys, websocket_endpoint_keys websocket_keys) 
        : _internal_rest_keys(std::move(rest_keys)), 
          _internal_websocket_keys(std::move(websocket_keys)), 
          path(std::move(path)) {};
private:
    rest_endpoint_keys _internal_rest_keys;
    websocket_endpoint_keys _internal_websocket_keys;
    std::string path;
};

这个方案通过虚函数实现类型擦除，既保留了tuple的编译时特性，又让data_endpoint和子类保持非模板化。唯一的代价是少量虚函数调用的运行时开销，大多数场景下可以忽略。

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