4

我有一个从可变参数类模板deriv派生的可变参数类模板base。

我有一个可以接受任何类型的函数模板T，以及类型的重载base<Ts...>；

base<Ts...>传递 a 时如何获得要使用的重载const deriv<Ts...>&？

下面的工作示例：

#include <iostream>
#include <tuple>

template<typename... Ts>
struct base
{
    std::tuple<Ts...> tuple;
};

template<typename... Ts>
struct deriv : base<Ts...>
{
};

//--------------------------------

template<typename T>
void func(const T&)
{
    std::cout << "T" << std::endl;
}

template<typename... Ts>
void func(const base<Ts...>&)
{
    std::cout << "base<Ts...>" << std::endl;
}

//----------------------------------------

int main()
{
    int a;
    base <int, double> b;
    deriv<int, double> c;

    func(a);
    func(b);
    func(c); // <--- I want func<base<Ts...>> not func<T> to be called here

    exit(0);
}

示例的输出：

T
base<Ts...>
T

我想要的输出是：

T
base<Ts...>
base<Ts...>
4

2 回答 2

6

除非你准备好重新设计你的代码，否则你不能，而且是有充分理由的。

您的非可变参数重载 的func()比可变参数版本更匹配：事实上，当尝试解析您的函数调用时，T非可变参数重载的类型参数将被推断为derived<int, double>.

另一方面，Ts可变参数重载中的参数包将被推断为int, double. 在类型推断之后，这实际上会给编译器留下这两种选择来解决您的调用：

void func(const deriv<int, double>&); // Non-variadic after type deduction
void func(const base<int, double>&);    // Variadic after type deduction

在尝试匹配参数为 type 的调用时应该选择哪一个derived<int, double>？

deriv<int, double> c;
func(c);

显然，第一个非可变参数重载是更好的匹配。

那么如何调用第二个重载而不是第一个呢？你有几个选择。首先，您可以通过显式指定模板参数来限定您的调用：

func<int, double>(c);

如果您不喜欢这样，也许您可​​以重新考虑非可变重载的定义func()：您真的希望它接受任何可能的类型T吗？或者是否有某些类型您知道不应调用此重载？如果是这样，您可以使用 SFINAE 技术并std::enable_if排除不需要的匹配。

作为进一步的可能性，您可以稍微放宽模板函数的签名，并允许将其参数推断为某个模板类的实例化：

template<template<typename...> class T, typename... Ts>
void func(const T<Ts...>&)
{
    std::cout << "base<Ts...>" << std::endl;
}

仅此更改就应该以您想要的方式修复程序的行为。

更新：

如果您希望仅对从类模板的任何实例派生的类调用专用函数模板，则base<>可以使用std::is_base_of<>类型特征并std::enable_if以下列方式：

template<template<typename...> class T, typename... Ts>
void func(
    const T<Ts...>&, 
    typename std::enable_if<
        std::is_base_of<base<Ts...>, T<Ts...>>::value
        >::type* = nullptr
    )
{
    std::cout << "base<Ts...>" << std::endl;
}

附录：

在模板函数重载对您的设计没有帮助的情况下，请注意您始终可以求助于部分模板专业化。不幸的是，函数模板不能被特化，但您仍然可以利用类模板的部分特化并添加一个辅助函数来隐藏该模板的实例化。这就是你重写代码的方式：

namespace detail
{
    template<typename T>
    struct X
    {
        static void func(const T&)
        {
            std::cout << "T" << std::endl;
        }
    };

    template<template<typename...> class T, typename... Ts>
    struct X<T<Ts...>>
    {
        static void func(const T<Ts...>&)
        {
            std::cout << "base<Ts...>" << std::endl;
        }
    };
}

template<typename T>
void func(const T& t)
{
    details::X<T>::func(t);
}
于 2013-02-03T23:42:27.037 回答
0

通用模板重载是一个更好的匹配，因为它不需要转换（除了添加const，两个重载都有）。

您可以base通过添加显式强制转换（示例）来获得 -template 重载：

func(static_cast<base<int, double> &>(c));

（或者，您可以放弃多个重载，而是将一些is_base_of辅助逻辑粘贴到主函数模板的主体中。）

于 2013-02-03T23:43:49.830 回答