c++ - 在类模板中分离参数包

Question

我正在尝试编写一个使用参数包并为参数包中包含的每种类型实现成员函数的类模板。

这是我目前所拥有的:

template <typename...T>
class Myclass {
public:
    void doSomething((Some_Operator_to_divorce?) T) {
        /*
         * Do Something
         */
        std::cout << "I did something" << std::endl;
    }
};

我的目标是拥有一个可以按以下方式使用的类模板:

Myclass<std::string, int, double> M;

M.doSomething("I am a String");
M.doSomething(1234);
M.doSomething(0.1234);

类模板机制将为 doSomething(std::string x)、doSomething(int x) 和 doSomething( double x) 成员函数，但不是 doSomething(std::string x, int i, double f) 成员函数。

我在网上找到了很多关于参数包可用性的例子，但我无法弄清楚它是否可以用于我的目的，或者我是否完全误解了参数包的用途。

我认为我需要解压参数包，但在阅读了很多关于解压参数包的示例后，我认为这不是正确的选择，它具有完全不同的含义。

因此，因此，我正在寻找一种“分离”参数包的操作。

Answer 1

没有专门支持此操作的“运算符(operator)”，但您可以根据您的要求以几种不同的方式完成您的请求。

“提取”的唯一方法T来自类模板参数包的类型以实现函数的重载集是使用递归继承来实现它，其中每个实例提取一个“T”类型并实现函数，通过剩下的交给下一个实现。

类似于:

// Extract first 'T', pass on 'Rest' to next type
template <typename T, typename...Rest>
class MyClassImpl : public MyClassImpl<Rest...>
{
public:
    void doSomething(const T&) { ... }
    using MyClassImpl<Rest...>::doSomething;
};

template <typename T>
class MyClassImpl<T> // end-case, no more 'Rest'
{
public:
    void doSomething(const T&) { ... }
};

template <typename...Types>
class MyClass : public MyClassImpl<Types...>
{
public:
    using MyClassImpl<Types...>::doSomething;
    ...
};

这将实例化 sizeof...(Types)类模板，其中每个模板都为每个 T 定义了一个重载类型。

这确保您获得重载语义——这样传递 int可以调用long过载，或者如果有两个竞争转换将是模棱两可的。

但是，如果这不是必需的，那么使用 enable_if 使用 SFINAE 启用该功能会更容易。和一个条件。

要进行精确比较，您可以创建一个 is_one_of仅当 T 时才确保此存在的特征正是其中的一种。在 C++17 中，这可以用 std::disjunction 来完成。和 std::is_same :

#include <type_traits>

// A trait to check that T is one of 'Types...'
template <typename T, typename...Types>
struct is_one_of : std::disjunction<std::is_same<T,Types>...>{};

或者，您可能希望它仅在适用于可转换类型时才有效——您可以这样做:

template <typename T, typename...Types>
struct is_convertible_to_one_of : std::disjunction<std::is_convertible<T,Types>...>{};

两者之间的区别在于，如果您将字符串文字传递给 MyClass<std::string> ，它将与第二个选项一起使用，因为它是可转换的，但不是第一个选项，因为它是精确的。推导T模板中的类型也会有所不同，前者恰好是 Types... 之一。 ，后者是可转换的(同样，T 可能是 const char* ，但 Types... 可能只包含 std::string )

将这一起工作到您的 MyClass模板，您只需要使用 enable_if 使用 SFINAE 启用条件:

template <typename...Types>
class MyClass
{
public:

    // only instantiates if 'T' is exactly one of 'Types...'
    template <typename T, typename = std::enable_if_t<is_one_of<T, Types...>::value>>
    void doSomething(const T&) { ... }

    // or 

    // only instantiate if T is convertible to one of 'Types...'
    template <typename T, typename = std::enable_if_t<is_convertible_to_one_of<T, Types...>::value>>
    void doSomething(const T&) { ... }
};

哪种解决方案适合您完全取决于您的要求(重载语义、精确调用约定或转换调用约定)

---

编辑:如果您真的想要变得复杂，您也可以合并这两种方法...制作一个类型特征以确定将从重载，并使用它构造特定底层类型的函数模板。

这类似于 variant 的方式需要实现，因为它有一个 U将所有类型视为重载集的构造函数:

    // create an overload set of all functions, and return a unique index for
    // each return type
    template <std::size_t I, typename...Types>
    struct overload_set_impl;

    template <std::size_t I, typename T0, typename...Types>
    struct overload_set_impl<I,T0,Types...>
      : overload_set_impl<I+1,Types...>
    {
      using overload_set_impl<I+1,Types...>::operator();

      std::integral_constant<std::size_t,I> operator()(T0);
    };

    template <typename...Types>
    struct overload_set : overload_set_impl<0,Types...> {};

    // get the index that would be returned from invoking all overloads with a T
    template <typename T, typename...Types>
    struct index_of_overload : decltype(std::declval<overload_set<Types...>>()(std::declval<T>())){};

    // Get the element from the above test
    template <typename T, typename...Types>
    struct constructible_overload
      : std::tuple_element<index_of_overload<T, Types...>::value, std::tuple<Types...>>{};

    template <typename T, typename...Types>
    using constructible_overload_t
      = typename constructible_overload<T, Types...>::type;

然后将其与具有函数模板的第二种方法一起使用:

template <typename...Types>
class MyClass {
public:
    // still accept any type that is convertible
    template <typename T, typename = std::enable_if_t<is_convertible_to_one_of<T, Types...>::value>>
    void doSomething(const T& v) 
    {
        // converts to the specific overloaded type, and call it
        using type = constructible_overload_t<T, Types...>;
        doSomethingImpl<type>(v); 
    }
private:
    template <typename T>
    void doSomethingImpl(const T&) { ... }

最后一种方法是两阶段的；它使用第一个 SFINAE 条件来确保它可以转换，然后确定适当的类型将其视为并将其委托(delegate)给真正的(私有(private))实现。

这要复杂得多，但可以实现类似重载的语义，而实际上不需要在创建它的类型中进行递归实现。