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

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

函数模板也是多态，而且是静态时多态

类模板也是静态时编译，也是多态