模板继承类, 调用父类的方法, 编译不过了, 为什么?

cdsfiui

下面几行小程序,VC可以编译过,可是gcc,clang却编译不过:

1. 
   
2. template<class T>
   
3. class Y
   
4. {
   
5. public:
   
6.     void f(){};
   
7. };
   
8. template<class T>
   
9. class X:public Y<T>
   
10. {
    
11. public:
    
12.     X()
    
13.     {
    
14.         f();
    
15.     }
    
16. };
    
17. int main()
    
18. {
    
19.     X<int> obj;
    
20.     return 0;
    
21. }
    

复制代码

GCC编译提示:
D:\Documents\TestProjects\main.cpp|139|error: there are no arguments to 'f' that depend on a template parameter, so a declaration of 'f' must be available [-fpermissive]|

Clang编译提示:
error: use of undeclared identifier 'f'
        f);

我如果改成了Y<T>::f()这样的调用，那就没有问题了。这是为什么呢，这个错误是C++标准规定了的吗?
问题:
1. 对于普通类，而非模板类而言，直接调用基类定义的函数，没有问题。为什么模板类需要我加上父类名称?
2. 这样一来，我在模板类继承体系中，凡是要调用父类的地方，岂不是都要显示的使用父类名称? 这种麻烦能否避免?

可能我理解的不到位，还请指针
谢谢。

OwnWaterloo

cdsfiui 发表于 2015-11-20 11:26
我如果改成了Y<T>::f()这样的调用，那就没有问题了。这是为什么呢，这个错误是C++标准规定了的吗?

是。。。

cdsfiui 发表于 2015-11-20 11:26
1. 对于普通类，而非模板类而言，直接调用基类定义的函数，没有问题。为什么模板类需要我加上父类名称?

处理模板时名字查找的方式不一样。。。

cdsfiui 发表于 2015-11-20 11:26
2. 这样一来，我在模板类继承体系中，凡是要调用父类的地方，岂不是都要显示的使用父类名称? 这种麻烦能否避免?

不能避免。。。  但除了Y<T>::f()外还有其他方式表达想要调用基类的f。。。
1. Y<T>::f()
2. this->f()
3. using Y<T>::f;


为什么X构造函数里写f()不表示调用继承得到的f。。。  至少有这么一个原因。。。
如果Y不是模板。。。 那Y一定有f函数。 但Y是类（主）模板。。。 这个就不一定了。。。  比如：

1. 
   
2. template<class T> class Y { public: void f() {} };
   
3. template<class T> class X : public Y<T> { public: X() { /* f() */ } };
   
4. template<class T> class Y<T*> {};
   

复制代码

Y<int> 就有f， 而Y<int*> 就没有。  于是 X<int>就（通过继承）有f， 而X<int*> 就没有。
只有用具体类型参数去实例化模板时，才能知道Y有没有f，以及X有没有继承f。
第2行那里继承的Y依然是参数化而不是具体的类型， 是不知道它有没有f， 也没办法"提前"去查看的， 偏特化故意写在后面怎么着。。。

https://isocpp.org/wiki/faq/temp ... t-name-lookup-types
https://gcc.gnu.org/onlinedocs/gcc/Name-lookup.html

bruceteen

只到实例化的时候，class X 是没法知道 f 是什么的。

hellioncu

想想为什么下面的代码输出：

1. #include <iostream>
   
2. 
   
3. void f()
   
4. {
   
5.         std::cout << "::f()" << std::endl;
   
6. }
   
7. 
   
8. template<class T>
   
9. class Y
   
10. {
    
11. public:
    
12.     void f(){std::cout << "Y::f()" << std::endl;};
    
13. };
    
14. template<class T>
    
15. class X:public Y<T>
    
16. {
    
17. public:
    
18.     X()
    
19.     {
    
20.         f();
    
21.     }
    
22. };
    
23. int main()
    
24. {
    
25.     X<int> obj;
    
26.     return 0;
    
27. }
    

复制代码

1. #include <iostream>
   
2. 
   
3. void f()
   
4. {
   
5.         std::cout << "::f()" << std::endl;
   
6. }
   
7. 
   
8. class Y
   
9. {
   
10. public:
    
11.     void f(){std::cout << "Y::f()" << std::endl;};
    
12. };
    
13. class X:public Y
    
14. {
    
15. public:
    
16.     X()
    
17.     {
    
18.         f();
    
19.     }
    
20. };
    
21. int main()
    
22. {
    
23.     X obj;
    
24.     return 0;
    
25. }
    

复制代码

lost_templar

1.     template<class T>
   
2.     class Y
   
3.     {
   
4.     public:
   
5.         void f(){};
   
6.     };
   
7.     template<class T>
   
8.     class X:public Y<T>
   
9.     {
   
10.     public:
    
11.         X()
    
12.         {
    
13.             (*this).f();
    
14.         }
    
15.     };
    
16.     int main()
    
17.     {
    
18.         X<int> obj;
    
19.         return 0;
    
20.     }

复制代码