c++ - 如何显式地将某些模板化输入作为参数？

Question

我有Foo<a, b>和 Foo<c, d>其中 Foo接受 2 个模板化参数。如果我有一个类为 SomeFunction 的可变参数模板接受那些 Foo像这样输入:

template <typename... Ts>
class SomeFunction< /*some input*/ >

我能做些什么来确保SomeFunction只需要 Foo模板，而不是像 Blah<a,b> 这样的其他模板？

Answer 1

您可以让您的类型私有(private)地继承自另一个类型，除非类型参数正确，否则无法实例化。您保留模板类型未定义，然后部分特化为 Foo<...>大小写，与列表的其余部分一起递归。

// Base template forward declaration, but note we don't define it.
template <typename...>
struct foo_validator;

// Specialization handling the terminating case.
template <>
struct foo_validator<> {};

// Partial specialization, handling Foo<a, b> followed by anything.  Note in particular
// how it inherits itself with the remainder of the type arguments.
template <typename T1, typename T2, typename ...Tail>
struct foo_validator<Foo<T1, T2>, Tail...> : foo_validator<Tail...> {};

// Now have SomeFunction privately inherit this type.
template <typename ...Ts>
class SomeFunction : private foo_validator<Ts...> {};

如果你传递除Foo<A, B>以外的任何类型参数(其中 A 和 B 可以是任何类型)那么所有特化都不会匹配，编译器将尝试实例化非特化模板。因为没有定义，所以会导致编译错误。

本声明:

SomeFunction<Foo<int, float>, std::pair<short, double>> a;

将失败:

error: invalid use of incomplete type 'struct foo_validator<std::pair<short int, double> >'

---

另一种方法非常相似，使用 static_assert :

// As before, this is the failing case, but we define it to inherit
// std::false_type.
template <typename...>
struct foo_validator : std::false_type {};

// The empty case is success and inherits std::true_type.
template <>
struct foo_validator<> : std::true_type {};

// Again, the "so-far-successful" partial specialization.
template <typename T1, typename T2, typename ...Tail>
struct foo_validator<Foo<T1, T2>, Tail...> : foo_validator<Tail...> {};

// Instead of inheriting foo_validator, we assert on its value member.
template <typename ...Ts>
class SomeFunction {
    static_assert(foo_validator<Ts...>::value, "All type arguments must be Foo<,>");
};

现在 SomeFunction 的错误实例化将失败:

error: static assertion failed: All type arguments must be Foo<,>

---

这是如何运作的？我们在两种方法中都有三个声明，它们在两种方法中都扮演相同的角色:

1. 我们声明一个接受任何类型参数作为失败案例的模板。
2. 我们针对没有类型参数的情况(vacuous truth)声明了此模板的特化。
3. 当第一个参数是 Foo 的实例化时，我们声明了一个偏特化。具有两个类型参数的模板类型，然后是任意数量(零个或多个)的其他类型参数。此类型继承了验证器模板类型，并删除了第一个类型参数(递归)。

让我们看一个示例，我们尝试实例化 SomeFunction<Foo<int, int>, Foo<float, double>> .

1. 编译器尝试实例化foo_validator<Foo<int, int>, Foo<float, double>> .这与部分特化相匹配，在上面的列表中键入 3。 ( T1 = int, T2 = int, Tail = [Foo<float, double>] ) 此类型继承 foo_validator<Foo<float, double>> .
2. 编译器尝试实例化foo_validator<Foo<float, double>> .这也匹配部分特化，即上面列表中的类型 3。 ( T1 = float, T2 = double, Tail = [] ) 此类型继承 foo_validator<> .
3. 编译器尝试实例化foo_validator<>并找到完全匹配的特化，在上面的列表中键入 2。在“继承foo_validator”方法中，没有任何反应，编译继续进行。在static_assert方法，此类型继承 std::true_type所以断言成功。

现在让我们看一个不应该工作的类型:SomeFunction<Foo<int, int>, std::pair<float, double>> :

1. 编译器尝试实例化foo_validator<Foo<int, int>, std::pair<float, double>> .这与部分特化相匹配，在上面的列表中键入 3。 ( T1 = int, T2 = int, Tail = [std::pair<float, double>] ) 此类型继承 foo_validator<std::pair<float, double>> .
2. 编译器尝试实例化foo_validator<std::pair<float, double>> .这与上面列表中的类型 2 或 3 不匹配，因此编译器尝试实例化基本模板声明(类型 1)。在“foo_validator 方法”中，这失败了，因为模板类型不完整(我们从未定义它)。在static_assert方法，基础模板被实例化并继承std::false_type , 所以断言失败。