Question

假设我有一个泛型类Container，它包含任何类型的元组，并且有一个函数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函数签名的情况下将Container转换为常规类？如同在不知道元组完整类型列表的情况下调用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
 };

检查live。

这可以通过多种方式进一步扩展，例如，您可以添加一个采用实际元组的构造函数，您可以通过索引访问并将值打包在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';
}

live demo

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

Answer 4

#include <iostream>

struct tuple_base {
    virtual ~tuple_base() {}
};

template <typename T>
struct leaf : virtual tuple_base {
    leaf(T const & t) : value(t) {}

    virtual ~leaf() {}

    T value;
};

template <typename ... T>
struct tuple : public leaf<T> ... {
    template <typename ... U>
    tuple(U && ... u) : leaf<T>{static_cast<U&&>(u)} ... {}
};

struct container {  
    tuple_base* erased_value;

    template <typename T>
    T & get() {
        return dynamic_cast<leaf<T>*>(erased_value)->value;
    }
};

int main() {
    container c{new tuple<int, float, char>{1, 1.23f, 'c'}};

    std::cout << c.get<float>() << std::endl;
}

关键是您必须了解有关元组类型结构的更多信息。仅使用它包含的单一类型从类型擦除的任意元组实现中提取信息是不可能的。这更像是一个概念证明，你可能最好不要使用别的东西，虽然它是你问的解决方案。

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

4 个答案: