在返回值容器类型中使用类型参数

Question

我正在尝试创建一组函数，允许它们的调用者将运行时变量值转换为特定于编译时的等效项。就我而言，运行时变量是 Windows IInspectables，转换过程通常称为“拆箱”（尽管出于我的 C++ 问题的目的，这些细节只是说明性的）。我希望转换函数适用于标量（例如 bool、int、double）、容器（例如 optional、pair、tuple、vector）和容器组合（例如 vector>）。容器拆箱函数应使用所包含类型的拆箱函数。

我知道可以通过输出参数的重载解析来表达所需的容器类型，例如

template<typename T1, typename T2>
void Unbox(/* in */ IInspectable* boxedValue, /* out */ std::pair<T1, T2>& unboxedValue)

template<typename T1, typename T2>
void Unbox(/* in */ IInspectable* boxedValue, /* out */ std::tuple<T1, T2>& unboxedValue)

是否可以通过返回值而不是输出参数来做同样的事情？我知道这是不正确/不可用的，但从概念上讲，我想定义……

template<typename T1, typename T2>
std::pair<T1, T2> Unbox(IInspectable* insp);

template<typename T1, typename T2>
std::tuple<T1, T2> Unbox(IInspectable* insp);

... 调用者控制是否创建一对或 2 元素元组。如果可能，实现这一目标的正确模式是什么？如果拆箱函数是（参数化）结构的（静态）方法，这是可以接受的。

Answer 1

要么给他们起不同的名字，比如

template<typename T1, typename T2>
std::pair<T1, T2> UnboxPair(IInspectable* insp);

template<typename T1, typename T2>
std::tuple<T1, T2> UnboxTuple(IInspectable* insp);

另一种选择是将完整的返回类型传递给函数

template<typename T>
T Unbox(IInspectable* insp) {
    using T1 = std::tuple_element_t<0, T>; // works on std::pair and std::array as
    using T2 = std::tuple_element_t<1, T>; // well as std::tuple
    ...
}

auto myTuple = Unbox<std::tuple<int, int>>(...);

第三种选择是将包含类型作为模板模板参数传递。

template<template <typename...> typename Container, typename T1, typename T2>
Container<T1, T2> Unbox(IInspectable* insp);

auto myPair = Unbox<std::pair, int, int>(...);

Answer 2

我喜欢“标签参数”选项：

// Possibly in "private" namespace

// structure for tag dispatching.
template <typename> struct Tag{};

// Overloads of the different Unbox implementations
// Allow custom-point for user classes.
template <typename T1, template T2>
std::pair<T1, T2> Unbox(Tag<std::pair<T1, T2>>, IInspectable*)
{
    // ...
}

template <typename Ts...>
std::tuple<Ts...> Unbox(Tag<std::tuple<Ts...>>, IInspectable*)
{
    // ...
}


float Unbox(Tag<float>, IInspectable*)
{
    // ...
}
// any other overloads, even a fallback for Tag<T>

所以用法是：

auto p = Unbox(Tag<std::pair<bool, float>>{}, inspectable);
auto t = Unbox(Tag<std::tuple<bool, float>>{}, inspectable);

要使用另一种语法，您可以这样做：

template <typename T>
T Unbox(IInspectable* inspectable)
{
    return Unbox(Tag<T>{}, inspectable);
}

所以用法会变成：

auto p = Unbox<std::pair<bool, float>>(inspectable);
auto t = Unbox<std::tuple<bool, float>>(inspectable);

• 注意：Tag 语法在模板函数中可能更简单，当这些重载是成员时：

  template <typename T> void (T& obj) { obj.Unbox(Tag<int>{}, inspectable); }

  对

  template <typename T> void (T& obj) { obj.template Unbox<int>(inspectable); }