重载、重写,重定义、多态、虚函数

重载:本质上还是函数不一样,函数名称一样但是参数不一样
重写:本质上是重写原来函数,函数名称参数都一样,通过虚函数实现
多态:只要是同一函数名实现不同功能,在外看来都是多态
虚函数:用于实现重写
重定义: 是指派生类的函数屏蔽了与其同名的基类函数,规则如下:
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、

函数模板也是多态,而且是静态时多态
在这里插入图片描述
类模板也是静态时编译,也是多态

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

  • 1
    点赞
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值