Question

我有一个容器类，其中存储一些抽象类的对象。在某些部分中，程序需要在实现类中获取这些对象。我写了一个通用的get函数，但是它必须遍历所有存储的对象，这会花费很多时间。据我所知，容器在每种类型中只有一个对象，我想在编译时解决此问题，但不想手动为每种类型创建自己的成员。

目前，我对“浪费的”运行时不感到困惑，但我想学习如何解决这个问题。

我当前的实现方式

#include <iostream>
#include <list>

class Abstract
{
public:
    virtual void update() = 0;
};

class ImplA : public Abstract
{
public:
    void update() {std::cout << "implA" << std::endl;}

};

class ImplB : public Abstract
{
public:
    void update() {std::cout << "implB" << std::endl;}

};

class Container
{
public:
    Container(){
        content.push_back(new ImplA);
        content.push_back(new ImplB);
    }

    void update() {
        for (Abstract* obj : content)
            obj->update();
    }

    template<typename T> T* get() const {
        for (Abstract* obj : content) {
            if(dynamic_cast<T*>(obj) != nullptr)
                return dynamic_cast<T*>(obj);
        }
        return nullptr;
    }

private:
    std::list<Abstract*> content;
};

int main()
{
    Container* container = new Container();
    container->get<ImplA>()->update();
    container->get<ImplB>()->update();
    return 0;
}

我的解决方法：

创建自己的成员并为每种类型获取函数
不是使用列表，而是使用地图，并使用typeinfo.name作为键（但这是运行时解决方案，不是一个好主意）
实施类型列表（例如，枚举类型{implA，implB}），并将其用作映射键。在这里，我必须为每种类型创建一个新条目。
使用诸如编译时间图之类的东西，它可以将类型用作键。

谢谢！

Answer 1

至少有两种主要方法可以提供对不同类型对象的恒定时间访问：

使用多重继承，转换为对象类型。
使用由std::unordered_set索引的哈希表（例如std::type_index）。

提供了编译时访问的多重继承方法的示例：

#include <iostream>
#include <vector>
using namespace std;

class Abstract
{
public:
    virtual void update() = 0;
};

class Impl_a : public Abstract
{
public:
    void update() override { cout << "impl A" << endl; }

};

class Impl_b : public Abstract
{
public:
    void update() override { cout << "impl B" << endl; }

};

template< class Type >
struct Boxed_
{
    Type object;
};

class Container:
    public Boxed_<Impl_a>,
    public Boxed_<Impl_b>
{
    vector<Abstract*> m_items;

    Container( const Container& ) = delete;
    auto operator=( const Container& ) -> Container& = delete;

public:
    void update()       // Not an override of base class function
    {
        for( Abstract* obj : m_items ) { obj->update(); }
    }

    template< class Type >
    auto get()
        -> Type*
    { return &static_cast<Boxed_<Type>&>( *this ).object; }

    Container():
        m_items{{ get<Impl_a>(), get<Impl_b>() }}
    {}
};

auto main()
    -> int
{
    Container c;
#ifdef INDIVIDUAL_CALLS
    c.get<Impl_a>()->update();
    c.get<Impl_b>()->update();
#else
    c.update();
#endif
}

如果您希望容器作为对非const对象的引用的const持有者，只需添加一个额外的间接级别即可。

这是David Wheeler撰写的软件工程的基本定理：

” 计算机科学中的所有问题都可以通过另一种间接解决方案来解决

Answer 2

如果您的对象总是插入在一起，那么您的问题已经由std::tuple解决了：

#include <iostream>
#include <tuple>

template <class... Ts>
struct Container : std::tuple<Ts...> {
    using std::tuple<Ts...>::tuple;

    void update() {
        std::apply([](auto &... objects){ (objects.update(), ...); }, *this);
    }
};

namespace std {
    template <class... Ts>
    struct tuple_size<Container<Ts...>> : tuple_size<tuple<Ts...>> { };
}

template <class... Ts>
Container(Ts...) -> Container<Ts...>;

Container通过隐式转换为std::tuple和特殊化std::tuple_size来支持std::get。

See it Live on Coliru（已针对C ++ 17之前的GCC进行了调整：/）

在编译时获取类型T的列表项

2 个答案: