C++中如何统一处理拥有相似接口的不同类型对象？

我需要存储大量不同类型的对象，这些对象彼此无关但拥有相似的接口（如初始化、配置、render等方法）。如何存储它们才能编写一次客户端代码，无需为每个容器重复实现？

目前我的实现如下（类名和方法签名仅作演示）：

struct Device {
   virtual void render();
};

struct Sensor : Device {
   virtual void render();
   void connect();
};

struct Regulator : Device {
   virtual void render();
};

class Scheme {
   std::vector<Device*> devices;
   std::vector<Sensor> sensors;
   std::vector<Regulator> regulators;
   // many containers
};

我使用sensors、regulators等容器存储特定类型对象，以便仅处理所需类型的少量对象，同时避免动态内存分配的巨大压力并获得其他收益：

void connect_sensors()
{
    std::for_each(sensors.begin(),sensors.end(),[](Sensor & sensor) { sensor.connect(); });
}

而使用devices容器统一处理所有对象的相似操作：

void render() {
   std::for_each(devices.begin(),devices.end(),[](Device *device) { device->render(); });
}

该方案的缺点是添加/移除对象时需同时更新特定容器和devices容器，存在遗漏导致数据不一致的风险。

另一种方案是移除devices容器，为每个特定容器单独调用render方法，但这会导致大量代码重复，且新增类型时容易遗漏对应的for_each调用。

我希望解决的问题是避免代码/数据重复，以及数据不一致的风险。

我不想仅使用devices容器并通过new动态分配所有对象的原因：

• 容器中对象数量庞大，当需要特定类型对象时，不想遍历所有对象；虽然可以通过分区解决，但会使方案过于复杂。
• 这些对象接口差异较大，不想每次需要特定类型时都使用dynamic_cast。

我需要一个能代表“所有容器”的实体，以便在客户端代码中统一处理所有对象。最佳实现方式是什么？

实际上，我不想承担额外的间接调用和vtable开销，因此如果有基于模板、元编程的方案能移除devices容器，那将是理想的选择。

可以借助C++的模板元编程和std::tuple来统一管理所有特定类型容器，既避免重复代码，又消除数据不一致的风险，同时完全避开虚函数的开销。

实现思路 #

1. 用std::tuple替代分散的容器成员，把所有特定类型的容器打包成一个tuple，通过模板遍历tuple中的每个元素。
2. 编写通用模板函数，对tuple中所有容器执行统一操作（比如render），无需为每个类型重复编写循环。
3. 封装对象的添加/移除逻辑，确保操作特定容器时无需维护额外的基类指针容器，从根源避免数据不一致。

代码示例 #

#include <tuple>
#include <vector>
#include <algorithm>

// 无需基类，保留各类型独立接口
struct Sensor {
   void render();
   void connect();
};

struct Regulator {
   void render();
};

class Scheme {
private:
    // 用tuple打包所有特定类型容器
    std::tuple<std::vector<Sensor>, std::vector<Regulator>> containers;

    // 模板辅助函数：遍历tuple并对每个容器执行操作
    template <typename Func, std::size_t... Idx>
    void for_all_containers(Func&& func, std::index_sequence<Idx...>) {
        (func(std::get<Idx>(containers)), ...);
    }

public:
    // 统一操作接口：自动遍历所有容器执行render
    void render() {
        for_all_containers([](auto& container) {
            std::for_each(container.begin(), container.end(), [](auto& obj) {
                obj.render();
            });
        }, std::make_index_sequence<std::tuple_size_v<decltype(containers)>>{});
    }

    // 特定类型操作：直接访问对应容器
    void connect_sensors() {
        auto& sensors = std::get<std::vector<Sensor>>(containers);
        std::for_each(sensors.begin(), sensors.end(), [](Sensor& sensor) {
            sensor.connect();
        });
    }

    // 封装对象添加逻辑，仅操作对应容器
    void add_sensor(const Sensor& sensor) {
        std::get<std::vector<Sensor>>(containers).push_back(sensor);
    }

    void add_regulator(const Regulator& regulator) {
        std::get<std::vector<Regulator>>(containers).push_back(regulator);
    }

    // 移除对象的方法同理，直接操作对应容器即可
};

方案优势 #

• 无额外性能开销：完全不需要虚函数，没有vtable和间接调用的损耗，所有操作都是编译期确定的。
• 数据一致性：不再需要维护额外的基类指针容器，统一操作直接基于真实的特定类型容器，不存在同步遗漏问题。
• 代码复用性高：新增类型时，只需在tuple中添加对应的容器类型，统一操作的函数（如render）无需修改；特定操作只需新增对应访问方法即可。
• 类型安全：所有操作都是编译期检查，避免dynamic_cast的运行时开销和潜在错误。

扩展说明 #

如果需要支持更多统一操作（比如init、configure），只需新增一个类似render的成员函数，复用for_all_containers辅助函数即可，无需重复编写循环逻辑。

新增类型时仅需两步：

1. 在Scheme的tuple成员中添加std::vector<NewType>。
2. 新增add_newtype方法（若需要），以及对应的特定操作方法（若该类型有独有的接口），统一操作函数无需任何修改。

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