C++ 复模板函数

当我看到这段代码时，我正在阅读关于模板的内容，这段代码让我非常困惑：

template<class T> class Y { };

template<class T, int i> class X {
   public:
      Y<T> f(char[20][i]) { return x; };
      Y<T> x;
};

template<template<class> class T, class U, class V, class W, int i>
   void g( T<U> (V::*)(W[20][i]) ) { };

int main()
{
   Y<int> (X<int, 20>::*p)(char[20][20]) = &X<int, 20>::f;
   g(p);
}

模板类Y{}；
模板类X{
公众：
yf（char[20][i]）{return x；}；
yx；
};
模板
无效g（T（V:*）（W[20][i]）{}；
int main（）
{
Y（X:：*p）（char[20][20]）=&X：：f；
g（p）；
}

你能给我解释一下这句话的意思吗

Y<int> (X<int, 20>::*p)(char[20][20]) = &X<int, 20>::f;

Y（X:：*p）（char[20][20]）=&X：：f；

我就是搞不懂它的意思。塔克斯

Y（X:：*p）（char[20][20]）=&X：：f；
Y<int> (X<int, 20>::*p)(char[20][20]) = &X<int, 20>::f;

声明指向类

X

的成员函数的成员函数指针

p

，该类接受指向20个

char

s数组的指针，并返回

Y

。然后使用类

X

Y（X:：*p）（char[20][20]）=&X:：f的成员函数
f
初始化该指针；

声明指向类

X

的成员函数的成员函数指针

p

，该类接受指向20个

char

s数组的指针，并返回

Y

。然后使用类

X

Y（X:：*p）（char[20][20]）=&X:：f的成员函数
f
初始化该指针；

声明指向类

X

的成员函数的成员函数指针

p

，该类接受指向20个

char

s数组的指针，并返回

Y

。然后使用类

X

Y（X:：*p）（char[20][20]）=&X:：f的成员函数
f
初始化该指针；

---

---

声明指向类

X

的成员函数的成员函数指针

p

，该类接受指向20个

char

s数组的指针，并返回

Y

。然后这个指针用类

X

@jrok的成员函数

f

初始化好了，这是指向二维数组地址的常量指针，对吗？@Joseph我知道，但这是我最讨厌的：）@spin_-eight不，它与

char（*）[20]

@spin_-eight完全一样。重点是第一个

[20]

具有误导性。它不是真正的数组类型，而是指针类型。类型为

char[20][20]

的参数实际上是“指向20

char

数组的指针”类型。这与类型为

char[400]

的参数（与

char*

完全相同）不同。@jrok OK，这是指向二维数组地址的常量指针，对吗？@Joseph我知道，但这是我最讨厌的：）@spin\u八不，它和

char（*）[20]

@spin\u八一样。重点是第一个

[20]

是误导性的。它不是真正的数组类型，而是指针类型。类型为

char[20][20]

的参数实际上是“指向20

char

数组的指针”类型。这与类型为

char[400]

的参数（与

char*

完全相同）不同。@jrok OK，这是指向二维数组地址的常量指针，对吗？@Joseph我知道，但这是我最讨厌的：）@spin\u八不，它和

char（*）[20]

@spin\u八一样。重点是第一个

[20]

是误导性的。它不是真正的数组类型，而是指针类型。类型为

char[20][20]

的参数实际上是“指向20

char

数组的指针”类型。这与类型为

char[400]

的参数（与

char*

完全相同）不同。@jrok OK，这是指向二维数组地址的常量指针，对吗？@Joseph我知道，但这是我最讨厌的：）@spin\u八不，它和

char（*）[20]

@spin\u八一样。重点是第一个

[20]

是误导性的。它不是真正的数组类型，而是指针类型。类型为

char[20][20]

的参数实际上是“指向20

char

数组的指针”类型。这与类型为

char[400]

的参数（与

char*

完全相同）不同。