重载:本质上还是函数不一样,函数名称一样但是参数不一样
重写:本质上是重写原来函数,函数名称参数都一样,通过虚函数实现
多态:只要是同一函数名实现不同功能,在外看来都是多态
虚函数:用于实现重写
重定义: 是指派生类的函数屏蔽了与其同名的基类函数,规则如下:
a 如果派生类的函数和基类的函数同名,但是参数不同,此时,不管有无virtual,基类的函数被隐藏。
b 如果派生类的函数与基类的函数同名,并且参数也相同,但是基类函数没有vitual关键字,此时,基类的函数被隐藏。
1.基类与子类之间可以重载吗?(重载仅类内部可用)
不可以,按照重载的定义在子类中写函数,那已经变成了重定义,原因是基类和子类作用域不同。
2.基类和子类之间可以重写吗?(重写仅类之间可用)
可以
3.基类内部可以重定义吗?(重定义仅类之间可用)
不可以,会报错,定义俩次。
注:在我看来除了返回值不同不可以将俩个函数看为是不相同的函数外,其余的,比如函数所处作用域,函数的参数类型,个数不同都可以看为不同的函数,既然是不同的函数那么就可以定义,并且分别调用。
不论是重载,重写,还是重定义,都可以直接按照是不同的函数调用,只要把他们不同的点指出来就可以调用。
如下图
#include<iostream>
using namespace std;
class Animal
{
public:
void func1(int tmp)//用于函数重载
{
cout << "I'm an animal " << tmp << endl;
}
void func1(const char *s)//函数的重载
{
cout << "I'm an animal func1 " << s << endl;
}
virtual void func2(int tmp)//用于重写
{
cout << "I'm virtual animal func2 " << tmp << endl;
}
void func3(int tmp)用于重定义
{
cout << "I'm an animal func3 " << tmp << endl;
}
};
class Fish :public Animal
{
public:
void func2(int tmp) //函数的重写, 覆盖父类的方法 override
{
cout << "I'm a fish func2 " << tmp << endl;
}
void func3(int tmp) { //函数的重定义 会隐藏父类同名方法.
cout << "I'm a fish func3 " << tmp << endl;
}
void func3()
{
cout<<"I'm fish func3 "<<endl;//函数重定义,与基类func3不仅作用域不同,而且参数不同,也是子类中func3重载函数
}
};
int main()
{
Fish fi;
Animal an;
an.func1("a");
an.func1(1);
cout<<("*******")<<endl;
//参数类型不同直接调用
an.func2(2);
fi.func2(2);
cout<<("********")<<endl;
//重写函数的作用域不同
an.func3(3);
fi.func3(3);
cout<<("*********")<<endl;
//重定义函数的作用域不同
an.func3(3);
fi.func3();
//重定义函数的作用域和参数均不同
return 0;
}
结果
那么既然如此,重定义和重写的区别和作用究竟是啥呢?
在上面那种情况下,确定没啥区别,请看下面重头戏:
#include<iostream>
using namespace std;
class Animal
{
public:
virtual void func2(int tmp)//用于重写
{
cout << "I'm virtual animal func2 " << tmp << endl;
}
void func3(int tmp)用于重定义
{
cout << "I'm an animal func3 " << tmp << endl;
}
};
class Fish :public Animal
{
public:
void func2(int tmp) //函数的重写, 覆盖父类的方法 override
{
cout << "I'm a fish func2 " << tmp << endl;
}
void func3(int tmp) { //函数的重定义 会隐藏父类同名方法
cout << "I'm a fish func3 " << tmp << endl;
}
};
void xu_han_shu(Animal *fi_an)//指向虚函数方式对象的指针做为参数
{
fi_an->func2(2);
};
void chong_ding_yi(Animal *fi_an)//指向重定义方式对象的指针做为参数
{
fi_an->func3(3) ;
};
int main()
{
Fish fi;
Animal an;
Animal *ptr;
ptr = &an;
xu_han_shu(ptr);
ptr = &fi;
xu_han_shu(ptr);
cout<<"********"<<endl;
//虚函数方式
ptr = &an;
chong_ding_yi(ptr);
ptr = &fi;
chong_ding_yi(ptr);
//重定义方式
return 0;
}
总结:在我看来重写,在调用时候与前面的情况完全不同,原因就是它的函数在定义时候看来是一个,但是执行结果却有俩个,其他的都是定义时候就可以知道其有不一样的地方,所以虚函数方式,才有运行时编译这个说法。
根据运行时传入的参数,对象不同,去调用不同的函数。其实就是相当于一般的一个函数,传入的参数类型是一致的,但是传入的数值不同然后得到不同的结果,我觉得是一种扩展思想。当然也实现了多态。
底层原理为什么会这样:如果不用虚函数的办法,当你子类去继承父类时候会直接拷贝一份父类的数据过来, 再加上自己类中的重定义的函数
一、定义函数时决定的多态
1.重载(类内部)
二、运行时决定的多态
1.参数为一般 同类型:
一个函数,结果由传入的具体值决定
2.参数为类 同类型:(类之间)
一个函数,结果由传入的具体对象决定
三、
重定义只是简单的覆盖而已,没实现多态,和多态没关系,就是用子类的函数覆盖掉继承来自父类的同名函数,以实现该函数和父类不一样的功能,没啥技术含量。优先选虚函数法.554、
函数模板也是多态,而且是静态时多态
类模板也是静态时编译,也是多态