Windows Xp
Dev C++ 4.9.9.2
代码1:编译通过
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
}
代码2:编译通不过
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test(int i){
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
}
请各位高手看看怎么回事?????
13 个解决方案
#1
出现的问题有下面两个。
1:在main 中,你的TEST函数中应该有参数(INT类型)
因为你已经重载了它。 下面是你重载的地方。
void Test(int i){
};
只要加个参数就OK了。
2:mian是int型的,但是你没有返回一个值,所以会有一个警告。
1:在main 中,你的TEST函数中应该有参数(INT类型)
因为你已经重载了它。 下面是你重载的地方。
void Test(int i){
};
只要加个参数就OK了。
2:mian是int型的,但是你没有返回一个值,所以会有一个警告。
#2
这样就可以了。
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test(){
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
return 0;
}
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test(){
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
return 0;
}
#3
和模板没有关系,子类隐藏了父类的同名函数。
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test1(int i){ // 改个名字即可
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
}
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test1(int i){ // 改个名字即可
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
}
#4
基类重载而已,为什么不可以啊
#5
ls的都说了
#6
重载当然可以了,可是你重载以后就要使用正却的参数啊。对不?
#7
派生类里定义的test将会屏蔽基类里的同名函数,尽管它们的参数类型不同。
在你调用E类的ea.Test();时首先在派生类里找名为Test的函数,如果找不到,会到基类里去找,如果找到了,就不再到基类里找了。然后,在找到的名为Test的函数里(如果有多个)找最佳匹配。在lz的程序里,在派生类里就找到了,然而参数类型又不匹配,所以出错。
要么删去派生类的Test函数,要么在派生类里重写Test()函数,来解决这个问题。
在你调用E类的ea.Test();时首先在派生类里找名为Test的函数,如果找不到,会到基类里去找,如果找到了,就不再到基类里找了。然后,在找到的名为Test的函数里(如果有多个)找最佳匹配。在lz的程序里,在派生类里就找到了,然而参数类型又不匹配,所以出错。
要么删去派生类的Test函数,要么在派生类里重写Test()函数,来解决这个问题。
#8
子类函数名跟父类相同,但参数不同不叫重载,叫隐藏。
#9
难道说重载之后就不可以,调用同名基类的方法了,不会吧,太不合理了
#10
所以对基类的同名函数,派生类里要么不重载,要么重载所有的。否则就会出现屏蔽现象。
#11
难道说重载之后就不可以,调用同名基类的方法了,不会吧,太不合理了
========================
可以调用基类里的同名函数,不过这时,你得显式指明是调用基类的那个函数。
========================
可以调用基类里的同名函数,不过这时,你得显式指明是调用基类的那个函数。
#12
谢谢大家,我想了下,明白成员变量可以子类可以隐藏父类成员变量,但不知道为什么子类成员函数也会这样子,太不方便了,马上散分
#13
haha
#1
出现的问题有下面两个。
1:在main 中,你的TEST函数中应该有参数(INT类型)
因为你已经重载了它。 下面是你重载的地方。
void Test(int i){
};
只要加个参数就OK了。
2:mian是int型的,但是你没有返回一个值,所以会有一个警告。
1:在main 中,你的TEST函数中应该有参数(INT类型)
因为你已经重载了它。 下面是你重载的地方。
void Test(int i){
};
只要加个参数就OK了。
2:mian是int型的,但是你没有返回一个值,所以会有一个警告。
#2
这样就可以了。
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test(){
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
return 0;
}
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test(){
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
return 0;
}
#3
和模板没有关系,子类隐藏了父类的同名函数。
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test1(int i){ // 改个名字即可
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
}
#include <cstdlib>
#include <iostream>
using namespace std;
class A{
public:
void Test(){
};
};
template<class T>
class E:public T{
//不同之处
public:
void Test1(int i){ // 改个名字即可
};
};
int main(int argc, char *argv[])
{
E<A> ea;
ea.Test();
}
#4
基类重载而已,为什么不可以啊
#5
ls的都说了
#6
重载当然可以了,可是你重载以后就要使用正却的参数啊。对不?
#7
派生类里定义的test将会屏蔽基类里的同名函数,尽管它们的参数类型不同。
在你调用E类的ea.Test();时首先在派生类里找名为Test的函数,如果找不到,会到基类里去找,如果找到了,就不再到基类里找了。然后,在找到的名为Test的函数里(如果有多个)找最佳匹配。在lz的程序里,在派生类里就找到了,然而参数类型又不匹配,所以出错。
要么删去派生类的Test函数,要么在派生类里重写Test()函数,来解决这个问题。
在你调用E类的ea.Test();时首先在派生类里找名为Test的函数,如果找不到,会到基类里去找,如果找到了,就不再到基类里找了。然后,在找到的名为Test的函数里(如果有多个)找最佳匹配。在lz的程序里,在派生类里就找到了,然而参数类型又不匹配,所以出错。
要么删去派生类的Test函数,要么在派生类里重写Test()函数,来解决这个问题。
#8
子类函数名跟父类相同,但参数不同不叫重载,叫隐藏。
#9
难道说重载之后就不可以,调用同名基类的方法了,不会吧,太不合理了
#10
所以对基类的同名函数,派生类里要么不重载,要么重载所有的。否则就会出现屏蔽现象。
#11
难道说重载之后就不可以,调用同名基类的方法了,不会吧,太不合理了
========================
可以调用基类里的同名函数,不过这时,你得显式指明是调用基类的那个函数。
========================
可以调用基类里的同名函数,不过这时,你得显式指明是调用基类的那个函数。
#12
谢谢大家,我想了下,明白成员变量可以子类可以隐藏父类成员变量,但不知道为什么子类成员函数也会这样子,太不方便了,马上散分
#13
haha