在c++11中为包含std::tuple的对象键入Erasure

Question

假设我有一个泛型类容器，它包含任何类型的元组，并且有一个函数template<typename T> T& get<T>();，它返回对元组中元素的引用。我非常简单的实现如下所示：

template<typename... Ts>
class Container
{
    std::tuple<Ts...> contents;

    public:
    Container(const Ts&... ts) : contents(ts...) {}

    template <typename T>
    T& get()
    {
        //TypeIndex is some meta-programming struct to find index of T in Ts
        return std::get<TypeIndex<T, Ts...>::value>(contents);
    }
};

有什么好的类型擦除技术可以在不改变get函数签名的情况下将容器转换为常规类吗？在不知道元组完整类型列表的情况下调用get<T>()？就像这样：

Struct A { int x; }
Struct B { int y; }
Struct C { int z; }

int main()
{
    Container container(A(), B()); //Underlying storage is a std::tuple<A, B>

    A& a = container.get<A>(); //Doesn't know the tuples type list but assumes A is in there.

    C& c = container.get<C>(); //C isn't in the tuples type list, crash program, which would be correct behavior.

}

boost::any是解决这些类型问题的常用方法，但并不能解决这个特殊问题，因为我必须知道要转换的底层元组的实际类型。就像我试图在上面的例子中使用它一样，我会做boost::any_cast<std::tuple<A, B>>来获得A，或者B，这对我没有任何用处，因为我有意隐藏元组类型列表。

编辑：对TypeIndex的完整定义。

#include <type_traits>

template <typename T, typename... Ts>
struct TypeIndex;

template <typename T, typename... Ts>
struct TypeIndex<T, T, Ts...> : std::integral_constant<std::size_t, 0> {};

template <typename T, typename U, typename... Ts>
struct TypeIndex<T, U, Ts...> : std::integral_constant<std::size_t, 1 + TypeIndex<T, Ts...>::value> {};

Answer 1

与手写的TypeIndex<T, Ts...>::value不同，您可以使用typeid(T)::hash_code()并将数据存储在std::unordered_map<size_t, boost::any>中。

std::tuple不存储有关基础类型的信息。该信息是以元组类型编码的。因此，如果您的get方法不能知道元组的类型，那么它就不能在存储值的地方得到偏移量。因此，您必须恢复到动态方法，而拥有一个映射是最简单的方法。

Answer 2

与目前提出的解决方案相比，一个稍微有效的解决方案是使用std::tuple作为实际的底层存储，从而避免使用any或unordered_map。

如果我们使用典型的类型擦除模式，我们只需要一个动态分配(加上复制实际对象所需的任何内容)，如果实现小缓冲区优化，则为零。

我们首先定义一个基本接口来按类型访问一个元素。

struct base
{
    virtual ~base() {}

    virtual void * get( std::type_info const & ) = 0;
};

我们使用void*而不是any来返回对对象的引用，从而避免了副本和可能的内存分配。

实际的存储类是从base派生的，并对它可以包含的参数进行模板化：

template<class ... Ts>
struct impl : base
{
    template<class ... Us>
    impl(Us && ... us) : data_(std::forward<Us>(us) ... ) 
    {
        //Maybe check for duplicated types and throw.
    }

    virtual void * get( std::type_info const & ti ) 
    {
        return get_helper( ti, std::index_sequence_for<Ts...>() );
    }

    template<std::size_t ... Indices>
    void* get_helper( std::type_info const & ti, std::index_sequence<Indices...> )
    {
        //If you know that only one element of a certain type is available, you can refactor this to avoid comparing all the type_infos
        const bool valid[] = { (ti == typeid(Ts)) ... };

        const std::size_t c = std::count( std::begin(valid), std::end(valid), true );
        if ( c != 1 )
        {
            throw std::runtime_error(""); // something here
        }

        // Pack the addresses of all the elements in an array
        void * result[] = { static_cast<void*>(& std::get<Indices>(data_) ) ... };

        // Get the index of the element we want
        const int which = std::find( std::begin(valid), std::end(valid), true ) - std::begin(valid);

        return result[which];
    }

    std::tuple<Ts ... > data_;
};

现在，我们只需将其包装在一个类型安全的包装器中：

class any_tuple
{
public:
     any_tuple() = default; // allow empty state

     template<class ... Us>
     any_tuple(Us && ... us) :
            m_( new impl< std::remove_reference_t< std::remove_cv_t<Us> > ... >( std::forward<Us>(us) ... ) )
       {}

     template<class T>
     T& get()
     {
        if ( !m_ )
        {
            throw std::runtime_error(""); // something
        }
        return *reinterpret_cast<T*>( m_->get( typeid(T) ) );
     }

     template<class T>
     const T& get() const
     {
         return const_cast<any_tuple&>(*this).get<T>();
     }

     bool valid() const { return bool(m_); }

 private:
     std::unique_ptr< base > m_; //Possibly use small buffer optimization
 };

看看吧，活着。

这可以在许多方面得到进一步的扩展，例如，您可以添加一个使用实际元组的构造函数，可以按索引进行访问并将值打包到std::any中，等等。

Answer 3

如果您可以使用boost::any，您可以使用它们的vector或unordered_map。下面是一个用unordered_map实现的版本

class Container
{
public:
    template<typename... Ts>
    Container(std::tuple<Ts...>&& t)
    {
        tuple_assign(std::move(t), data, std::index_sequence_for<Ts...>{});
    }

    template<typename T>
    T get()
    {
        auto it = data.find(typeid(T));

        if(it == data.cend()) {
            throw boost::bad_any_cast{};
        } else {
            return boost::any_cast<T>(it->second);
        }
    }

private:
    std::unordered_map<std::type_index, boost::any> data;
};

然后你就可以按照你的要求写了。我将构造函数更改为接受元组，以避免大量的sfinae代码，以防止过脊复制/移动构造函数，但如果您愿意，可以这样做。

Container c(std::make_tuple(1, 1.5, A{42}));

try {
    std::cout << "int: " << c.get<int>() << '\n';
    std::cout << "double: " << c.get<double>() << '\n';
    std::cout << "A: " << c.get<A>().val << '\n';
    c.get<A&>().val = 0;
    std::cout << "A: " << c.get<A>().val << '\n';
    std::cout << "B: " << c.get<B>().val << '\n'; // error
} catch (boost::bad_any_cast const& ex) {
    std::cout << "exception: " << ex.what() << '\n';
}

现场演示

还可以指示Container提交std::terminate()，而不是抛出异常。