一个模板特化的匹配问题

oract666

原帖由 tyc611 于 2007-2-2 13:13 发表

请问一下，你是什么编译器，我是MinGW2.05

我是vs.net 2005

另外在Linux上 g++下：
[oracle@test cpp]$ ./ttt
template
Specialization: char[6]
Specialization: char[6]

whyglinux

>>>> The top-level cv-qualifiers on the template-parameter are ignored when determining its type.
>> 不是很明白你上面这儿的意思，能否举例说明一下

当从给定的参数推导模板类型的时候，最上层的 cv 限定（const 或 volatile 等）将被忽略。例如，"hello" 的类型是 const char[6]，去掉 const 之后的 char[6] 作为模板参数 T。

我怀疑 oract666 给出的结果是编译器的一个缺陷。

tyc611

> 当从给定的参数推导模板类型的时候，最上层的 cv 限定（const 或 volatile 等）将被忽略。例如，"hello" 的类型是
> const char [6]，去掉 const 之后的 char[6] 作为模板参数 T。
有这种转换么？C++ Primer介绍了几种有限转换（见9楼），不包括这种情况，请问那能找到参考？
另外，如果按这种转换，那么在1楼的代码中，第一行输出应该是“Specialization: char*”而非“template”吧？

> 我怀疑 oract666 给出的结果是编译器的一个缺陷。
相反，我觉得这种行为才正常，是不是GCC对const char[NUM]做了特殊处理？因为找不到方式表达我1楼的第二个问题，而其它类型就可以（比如:char*和const char*)

whyglinux

>> 有这种转换么？C++ Primer介绍了几种有限转换（见9楼），不包括这种情况，请问那能找到参考？

你所引用的“const转换：接受const引用或const指针的函数可以分别用非const对象的引用或指针来调用，而无须产生新的实例化。”就是这种情况。无论实参是用 const 限定的对象还是非 const 限定的对象，都调用的是同一实例，不是吗？

>> 另外，如果按这种转换，那么在1楼的代码中，第一行输出应该是“Specialization: char*”而非“template”吧？

注意 “top-level” 的限定。const char *p1 中的 const 不位于最上层。const char * const p1 中的第二个 const 才是一个所谓的最上层的限定符。

tyc611

>> 无论实参是用 const 限定的对象还是非 const 限定的对象，都调用的是同一实例，不是吗？
对，我也是这个意思
>> 注意 “top-level” 的限定。const char *p1 中的 const 不位于最上层。const char * const p1 中的第二个 const 才是一个所谓的最上层的限定符。
I got it. 3ks

另外，我在1楼修改了下代码和问题描述，特别是绿色部分，比如其中的a3是const char[6]类型，为什么还匹配到<char[6]>而不是匹配到<const char[6]>？有时间帮忙看看，谢谢

whyglinux

>> 比如其中的a3是const char[6]类型，为什么还匹配到<char[6]>而不是匹配到<const char[6]>？

因为 const char[6] 类型中的 const 就是一个上面所说的 top-level 限定符，所以从这个类型推导出的模版参数 T 的类型为 char[6]，而不会是 const char[6]。

>> 对于数组类型，下面的那个绿色的const char[NUM]类型的版本似乎没有机会被选用（我没找到方法），无论实参数组是const还是非const，都匹配到形参为非const数组的 const引用。

是的，如果你让编译器来自动推导模版参数，那个 const char[6] 版本的特化函数永远不会调用到。只能通过显式指定模版参数的方法来调用此函数，如：func<const char[6]>(a1, a2);

>> 而对于指针类型就不一样，从第二个输出结果可看出这两者之间的区别

const char * 类型中的 const 不是 top-level 限定符，所以在模版参数的推导过程中 const char * 成为不了 char *。

tyc611

非常感谢 whyglinux 版主和大家的帮助！
但是昨晚睡觉时又好好想了想，发现了点问题，为了让大家看到，放下面帖子里了

[ 本帖最后由 tyc611 于 2007-2-3 10:40 编辑 ]

tyc611

The top-level cv-qualifiers on the template-parameter are ignored when determining its type.

注意 “top-level” 的限定。const char *p1 中的 const 不位于最上层。const char * const p1 中的第二个 const 才是一个所谓的最上层的限定符。

我发现一个问题，被忽略的top-levev CV-qualifiers指模板形参中的还是调用实参中的，好像我们的理解不一样。

你应该是认为是调用实参中的被忽略，

>> 比如其中的a3是const char[6]类型，为什么还匹配到<char[6]>而不是匹配到<const char[6]>？

因为 const char[6] 类型中的 const 就是一个上面所说的 top-level 限定符，所以从这个类型推导出的模版参数 T 的类型为 char[6]，而不会是 const char[6]。

而我认为是模板形参中的被忽略，写了下面的测试代码证明我的理解

const转换：接受const引用或const指针的函数可以分别用非const对象的引用或指针来调用，而无须产生新的实例化。

1. 
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. template<typename T>
   
6.     void func (T &v1, T &v2) {
   
7.         cout<<"template"<<endl;
   
8.     }
   
9.           
   
10. template <>
    
11.     void func<const char*> (const char* &v1, const char* &v2) {
    
12.         cout<<"Specialization: const char*"<<endl;
    
13.     }
    
14.        
    
15. template <>
    
16.     void func<char [6]> (char (&v1)[6], char (&v2)[6]) {
    
17.         cout<<"Specialization: char[6]"<<endl;
    
18.     }
    
19.    
    
20. int main()
    
21. {
    
22.     const char * p1 = "hello";
    
23.     const char * p2 = "world";
    
24.     func(p1, p2);
    
25.    
    
26.     const char * const p3 = "hello";
    
27.     const char * const p4 = "world";
    
28.     func(p3, p4);
    
29.    
    
30.     char a1[6] = "hello";
    
31.     char a2[6] = "world";
    
32.     func(a1, a2);
    
33.         
    
34.     const char a3[6] = "hello";
    
35.     const char a4[6] = "world";
    
36.     func(a3, a4);
    
37.         
    
38.     return 0;
    
39. }

复制代码

输出结果为：

Specialization: const char*
template
Specialization: char[6]
template

回到原来的问题，我觉得可以这样解释了：

在下面的代码中，之所以func(a3, a4)调用匹配到下面的特化版本，是因为编译器特别处理：认为a3和a4是一个char[6]的“const对象”，这样当然可以匹配到char[6]的const引用。

但是，在C++中不存在char[NUM]的const对象，因为const char[NUM]实质上是const char的数组对象，const是修饰数组元素类型而非整个数组类型。这就解释了为什么编译器永远也推断不出<const char[6]>类型的版本。

或许，这是编译器对数组这个特殊类型的特殊处理吧。这样的解释与上面的代码也不会冲突。

1. 
   
2. const char a3[6] = "hello";
   
3. const char a4[6] = "world";
   
4. func(a3, a4);
   
5. 
   
6. template <>
   
7.     void func<char [6]> ( char const (&v1)[6],  char const (&v2)[6]) {
   
8.         cout<<"Specialization: char[6]"<<endl;
   
9.     }
   

复制代码

whyglinux

模板参数推导的前提条件是首先函数的签名特征要符合。在上面给出的第一个例子中，p1、p2、a1、a2 等变量都不是 const 限定的，而 a3、a4、p3、p4 都是 const 限定的（这样的 const 就是一个 top-level 限定符）；而你给出的两个特化函数的参数不是 const 引用的形式，所以如果用 a3、a4 或者 p3、p4 等 const 限定的变量来作为函数参数的话是不可能与这两个特化函数相匹配的，所以对这两个特化函数进行模板参数推导也就没有必要了。

再强调一遍：正是因为有了“The top-level cv-qualifiers on the template-parameter are ignored when determining its type.” 这一规定，所以才导致了“const转换：接受const引用或const指针的函数可以分别用非const对象的引用或指针来调用，而无须产生新的实例化。”这一结论。

>> 或许，这是编译器对数组这个特殊类型的特殊处理吧。

你的意思是如果不是数组类型，比如函数实参是一个 const int 类型的变量的话，那么它进行模板参数推导的时候 top-level 的 const 不能被忽略，从而能够调用一个模板参数为 const int 的特化函数吗？你很容易可以验证这一点，从而知道你上面的结论是否正确。

tyc611

恩，理解了，非常感谢 whyglinux 版主的耐心帮助！

最后写两段代码说明

1. #include <iostream>
   
2. using namespace std;
   
3. 
   
4. template<typename T>
   
5.     void func (T &v1, T &v2) {
   
6.         cout<<"template"<<endl;
   
7.     }
   
8.    
   
9. template<typename T>
   
10.     void func (const T &v1, const T &v2) {
    
11.         cout<<"template const"<<endl;
    
12.     }
    
13.        
    
14. template <>
    
15.     void func<char [6]> ( char const (&v1)[6],  char const (&v2)[6]) {
    
16.         cout<<"Specialization: char[6]"<<endl;
    
17.     }
    
18. 
    
19. template <>
    
20.     void func<const char [6]> (char const(&v1)[6], char const(&v2)[6]) {
    
21.         cout<<"Specialization: const char[6]"<<endl;
    
22.     }
    
23.    
    
24. int main()
    
25. {   
    
26.     const char * const p3 = "hello";
    
27.     const char * const p4 = "world";
    
28.     func(p3, p4);
    
29.    
    
30.     const char a3[6] = "hello";
    
31.     const char a4[6] = "world";
    
32.     func(a3, a4);
    
33.         
    
34.     return 0;
    
35. }
    

复制代码

运行输出结果：

template const
Specialization: char[6]

注意：上面的代码中最后一个特化版本是第二个模板的特化，这个比较特殊，这也可以利用编译器验证：将最后一个特化重复定义可得到如下错误信息

main.cpp:25: error: redefinition of `void func(const T&, const T&) [with T = const char[6]]'
main.cpp:20: error: `void func(const T&, const T&) [with T = const char[6]]' previously declared here

另一段对比代码：

1. 
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. template<typename T>
   
6.     void func (T &v1, T &v2) {
   
7.         cout<<"template"<<endl;
   
8.     }
   
9. 
   
10. template <>
    
11.     void func<const char [6]> (char const(&v1)[6], char const(&v2)[6]) {
    
12.         cout<<"Specialization: const char[6]"<<endl;
    
13.     }
    
14.    
    
15. int main()
    
16. {   
    
17.     const char a3[6] = "hello";
    
18.     const char a4[6] = "world";
    
19.     func(a3, a4);
    
20.         
    
21.     return 0;
    
22. }
    

复制代码

程序运行输出：

Specialization: const char[6]

今天下午去拿到了票，明天就上火车了，回家了，好高兴～～hoho