C++模板: one list by class,如何分解代码？

Question

假设我有这个类(class):

class Component1;
class Component2;
// many different Components
class Component42;

class MyClass
{
public:
    MyClass(void) {};
    std::list<Component1> component1List;
    std::list<Component2> component2List;
    // one list by component
    std::list<Component42> component42List;
};

我想创建一个具有以下签名的函数:

template<class T> void addElement(T component);

它应该执行以下操作:

• 如果 component 是 Component1 类型，则将其添加到 Component1List
• 如果component属于Component2类型，则将其添加到Component2List等

有可能吗？有什么好的方法可以做到这一点？

我可以使用类似的函数获得相同的行为:

template<class T> void addElement(int componentType, T component);

但我宁愿不必像这样指定 componentType :这是无用的信息，它为可能的错误打开了大门(如果 componentType 不代表组件类型)。

Answer 1

std::tuple 来救援。

变更日志:

• 使用 std::decay_t

• 添加了可变参数形式

• add_component() 现在返回对此的引用以允许调用链。

---

#include <iostream>
#include <list>
#include <utility>
#include <type_traits>
#include <tuple>

class Component1 {};
class Component2 {};
struct Component3 {
    Component3() {}
};
// many different Components

template<class...ComponentTypes>
class MyClassImpl
{
    template<class Component> using list_of = std::list<Component>;

public:

    using all_lists_type =
    std::tuple<
    list_of<ComponentTypes> ...
    >;


    // add a single component
    template<class Component>
    MyClassImpl& add_component(Component&& c)
    {
        list_for<Component>().push_back(std::forward<Component>(c));
        return *this;
    }

    // add any number of components
    template<class...Components>
    MyClassImpl& add_components(Components&&... c)
    {
        using expand = int[];
        void(expand { 0, (void(add_component(std::forward<Components>(c))), 0)... });
        return *this;
    }



    template<class Component>
    auto& list_for()
    {
        using component_type = std::decay_t<Component>;
        return std::get<list_of<component_type>>(_lists);
    }

    template<class Component>
    const auto& list_for() const
    {
        using component_type = std::decay_t<Component>;
        return std::get<list_of<component_type>>(_lists);
    }


private:

    all_lists_type _lists;
};

using MyClass = MyClassImpl<Component1, Component2, Component3>;

int main()
{
    MyClass c;

    c.add_component(Component1());
    c.add_component(Component2());

    const Component3 c3;
    c.add_component(c3);

    c.add_components(Component1(),
                     Component2(),
                     Component3()).add_components(Component3()).add_components(Component1(),
                                                                               Component2());

    std::cout << c.list_for<Component1>().size() << std::endl;

    return 0;
}