C++ 在专门化类时，如何获取不同数量的模板参数？

我只是问了一个问题：他的答案是这样的：

template<class T>
struct get_memfun_class;

template<class R, class T, class...Args>
struct get_memfun_class<R(T::*)(Args...)> {
    using type=T;
};

是否没有要求专业化必须采用相同数量的参数

是否没有要求专业化必须采用相同数量的参数

有,；并对你的例子感到满意

当你写作时

template<class T>
struct get_memfun_class;

template<class R, class T, class...Args>
struct get_memfun_class<R(T::*)(Args...)> {
    using type=T;
};

您定义了一个专门化，该专门化以

R（T:：*）（Args…

的形式接收单个模板typename参数

从单个类型

R（T::*）（Args…

，可以推断出多个模板参数（

R

，

T

和变量

Args…

，在本例中），但类型

R（T:：*）（Args…

（接收变量参数列表的类的方法）仍然是一个

例如，这样的事情合法吗

template<typename T>
void foo(const T&);

template<typename K, typename V>
void foo<pair<K, V>>(const pair<K, V>&);

是否没有要求专业化必须采用相同数量的参数

有,；并对你的例子感到满意

当你写作时

template<class T>
struct get_memfun_class;

template<class R, class T, class...Args>
struct get_memfun_class<R(T::*)(Args...)> {
    using type=T;
};

您定义了一个专门化，该专门化以

R（T:：*）（Args…

的形式接收单个模板typename参数

从单个类型

R（T::*）（Args…

，可以推断出多个模板参数（

R

，

T

和变量

Args…

，在本例中），但类型

R（T:：*）（Args…

（接收变量参数列表的类的方法）仍然是一个

例如，这样的事情合法吗

template<typename T>
void foo(const T&);

template<typename K, typename V>
void foo<pair<K, V>>(const pair<K, V>&);

---

您似乎混淆了显式专门化的模板参数和用于专门化模板的模板参数

template<class T> // one argument
struct get_memfun_class; // get_memfun_class takes one template (type) argument

template<class R, class T, class...Args>
struct get_memfun_class<R(T::*)(Args...)> {
//                      ^^^^^^^^^^^^^^^^
//                      one type argument
    using type=T;
}; // explicit specialization takes one template argument

template//一个参数
结构get_memfun_class；//get_memfun_类接受一个模板（类型）参数
样板
结构get\u memfun\u类{
//                      ^^^^^^^^^^^^^^^^
//一类参数
使用类型=T；
}; // 显式专门化接受一个模板参数

是的，显式专门化有三个模板参数，但这并不意味着显式专门化需要三个参数。它们是可以推断的。您可以使用多个类型参数形成一个单一类型，这就是这里发生的情况。还要考虑你可以完全专门化一个模板：

template <>
struct get_memfun_class<void>;
//                      ^^^^
//                    one type argument

模板
结构get_memfun_类；
//                      ^^^^
//一类参数

这里也是一样。是的，显式专门化不接受任何参数，但这只是意味着没有可推导的参数，实际上您正在显式编写模板参数（

void

），因此专门化的模板参数数量与主模板的参数数量匹配

template<class T> // one argument
struct get_memfun_class; // get_memfun_class takes one template (type) argument

template<class R, class T, class...Args>
struct get_memfun_class<R(T::*)(Args...)> {
//                      ^^^^^^^^^^^^^^^^
//                      one type argument
    using type=T;
}; // explicit specialization takes one template argument

---

您的示例无效，因为您无法部分专门化函数。

您似乎混淆了显式专门化的模板参数和用于专门化模板的模板参数

template<class T> // one argument
struct get_memfun_class; // get_memfun_class takes one template (type) argument

template<class R, class T, class...Args>
struct get_memfun_class<R(T::*)(Args...)> {
//                      ^^^^^^^^^^^^^^^^
//                      one type argument
    using type=T;
}; // explicit specialization takes one template argument

template//一个参数
结构get_memfun_class；//get_memfun_类接受一个模板（类型）参数
样板
结构get\u memfun\u类{
//                      ^^^^^^^^^^^^^^^^
//一类参数
使用类型=T；
}; // 显式专门化接受一个模板参数

是的，显式专门化有三个模板参数，但这并不意味着显式专门化需要三个参数。它们是可以推断的。您可以使用多个类型参数形成一个单一类型，这就是这里发生的情况。还要考虑你可以完全专门化一个模板：

template <>
struct get_memfun_class<void>;
//                      ^^^^
//                    one type argument

模板
结构get_memfun_类；
//                      ^^^^
//一类参数

这里也是一样。是的，显式专门化不接受任何参数，但这只是意味着没有可推导的参数，实际上您正在显式编写模板参数（

void

），因此专门化的模板参数数量与主模板的参数数量匹配

template<class T> // one argument
struct get_memfun_class; // get_memfun_class takes one template (type) argument

template<class R, class T, class...Args>
struct get_memfun_class<R(T::*)(Args...)> {
//                      ^^^^^^^^^^^^^^^^
//                      one type argument
    using type=T;
}; // explicit specialization takes one template argument

---

你的例子是无效的，因为你不能部分地专门化函数。

“这显然是……的两种专门化。”呃，只有一种专门化。我不理解这个问题。不同数量的模板参数是什么意思？该示例的模板参数（

R

、

T

和

Args

）的数量与主（

T

）不同。另外，

foo

示例是不合法的，因为你不能部分专门化函数模板。@Barry不是第二个合法的，因为它是一个重载，不是一个部分专门化？@NathanOliver它作为重载是合法的，但它是作为一个部分专门化编写的。啊，是的，错过了那部分。“这显然是……”的两个专门化。呃，只有一个专门化。我不明白这个问题。你说不同数量的模板参数是什么意思？这个例子的模板参数（

R

，

t

，和

Args

）的数量与主（

t

）不同。此外，

foo

示例是不合法的，因为你不能部分专门化函数模板。@Barry不是第二个合法的，因为它是一个重载，而不是一个部分专门化？@NathanOliver它作为重载是合法的，但它是作为一个部分专门化编写的。啊，是的，错过了那部分。第一个意思（“是；…）似乎与您后来写的内容相矛盾：“一个专门化接收一个模板typename参数”@user463035818-您是对的：“是”作为一个以“有没有”开头的问题的回答不是一个好主意；谢谢。修改为“有”。第一个意思（“是；…”）似乎与您后来写的内容相矛盾：接收单个模板typename参数“@user463035818-您是对的，作为对以“是否存在”开头的问题的回答：“是”