可变参数模板容器类中是否可以使用无模板 Getter？

Question

据我所知，假设的可变参数模板元组类必须使用带有模板参数的 getter。

int MyInt = MyTuple.Get<int>(0);

这很不方便，并且可能会出现错误。我忍不住觉得有一种方法可以构造该类，因此您不必显式指定它。

int MyInt = MyTuple.Get(0);

我的第一个想法是让 Get() 成员函数返回另一个类，该类可以自行计算类型，可能通过将 typeid(Foo).name() 与一些预先计算的列表中的值。不过，这仍然必须在运行时之前发生，而且我无法找到在编译时迭代类似内容的方法。

有没有办法让可变参数模板容器类（如元组）拥有不需要显式指定类型的 getter？

Answer 1

你的意思是像std::tuple？

getter 的模板参数指定成员的索引，而不是类型。根据定义，元组的数量和类型在编译时是固定的。由于类型取决于索引，并且类型必须在编译时已知，因此必须对 getter 进行模板化。

template< typename ... types >
struct tuple;

template< typename head, typename ... tail_types >
struct tuple {
    head value;
    tuple< tail_types ... > tail;
};

template<>
struct tuple<> {};

template< typename tuple, size_t index >
struct tuple_element;

template< typename head, typename ... tail, size_t index >
struct tuple_element< tuple< head, tail ... >, index >
    { typedef typename tuple_element< tail ..., index - 1 >::type type; };

template< typename head, typename ... tail >
struct tuple_element< tuple< head, tail ... >, 0 >
    { typedef head type; };

template< size_t index, typename tuple >
typename std::enable_if< index != 0, 
                   typename tuple_element< tuple, index >::type >::type
get( tuple const &t )
    { return get< index - 1 >( t.tail ); }

template< size_t index, typename tuple >
typename std::enable_if< index == 0,
                   typename tuple_element< tuple, index >::type >::type
get( tuple const &t )
    { return t.value; }

ETC。

Answer 2

C++ 的规则通常不允许您要求的内容。

结构体是已知类型值的集合，可以通过必须在编译时提供的名称来访问这些值。最后一部分至关重要，因为它允许 C++ 编译器知道您正在谈论哪个值。

元组是已知类型值的集合，可以通过数字访问这些值。但是，仅仅因为它是一个数字并不意味着它可以是运行时定义的数字，就像具有结构成员的字符串名称并不意味着您可以在运行时获取该成员一样。

元组的每个成员都是类型化的，C++ 需要在编译时知道事物的类型才能发挥作用。同样，任何函数的返回类型在编译时都是已知的；它不能根据参数的值而改变。您可以根据类型（函数重载或模板参数推导）选择不同的函数，但它不能基于值，因为值（除非它们是编译时常量）仅在运行时已知。

为了做你想做的事，你必须以某种方式破坏 C++ 类型系统。例如，理论上您可以有一个返回无类型指针的 get 函数。或者，如果您至少想要某种类型安全的伪装，可能是元组的 boost::any 或 boost::variant > 的类型。但这就是你能做的最好的事情了。

即使您在编译时指定类型 (get)，由于类型不匹配的可能性，这仍然不够好。那你怎么办？

这个概念在像 C++ 这样的编译时类型语言中是行不通的。

Answer 3

MyTuple.Get(0); 这种 Get 声明的返回类型是什么？如果您同意它返回元组中每种可能类型的变体，那么您可以让它工作，是的。

另一方面，Boost.Tuple 和 C++0x Tuple 将索引作为模板参数。那里没有犯错误的可能性。检查一下。

Answer 4

标准库包含 std::get 函数模板，可与 std::tuple 和 std::pair 配合使用，并且不需要类型予以明确指定。它的工作原理是将索引作为模板参数。

std::tuple<int,std::string,char const*> t(1,"foo","blah");
auto i = std::get<0>(t); // i is int
auto s = std::get<1>(t); // s is std::string
auto p = std::get<2>(t); // p is char const*

返回类型必须始终在编译时已知，并且它取决于索引，因此您不可能将索引作为运行时参数。

Answer 5

这不是假设。 boost::tuple 的行为如您所描述的那样。

boost::tuple<int, float> myTuple = boost::make_tuple(10, 3.1);
int myInt = myTuple.Get<0>();

Answer 6

因此，您已经收到了一些回复，解释说如果您将索引作为编译时参数传递，那么这将起作用。不过，我想评论一下总体想法：

我想我已经看到了返回具有模板化隐式转换运算符的代理的技巧：（

template<typename T> operator T()

不过，我懒得在代码中检查这一点。如果有人愿意这样做工作并展示一个工作示例，请在这里给我发表评论，我可能会投票。）

当然，与往常一样，对于此类黑客，您需要问自己这是否值得。隐式转换随时都会让您陷入困境。 （我曾经认为有时它们并不是邪恶的。但有一天我不得不删除我的工作代码中的最后一个隐式转换，因为它引入了一个很难发现的错误，并且发誓永远不会再次使用它们。）
此外，必须拼写出类型的额外安全性可以充当安全带（防止您在严重失败时压碎挡风玻璃）。
最后，C++11 允许这样做：

auto foo = bar.get<int>(); // available today at a compiler near you

看，类型只拼写一次。 <代码>:)

Answer 7

您当然可以这样做，但可能不值得。一种方法是提供一个静态函数，将可变参数模板实例成员转换为 boost::any 并拥有一个静态函数表：

template <...> class any_tuple 
{
...
    typedef boost::any (*extract_member)(any_tuple &);
    static extract_member member_extrators[...];

    boost::any Get(int index) { return member_extractors[index](*this); }
};

但是随后您必须担心初始化和所有问题那个东西。