C++中的重载，覆盖，和重定义（同名隐藏）

一、基础概念

1. 重载：函数在同一作用域中，且函数名字相同，参数列表不同。
   注意：只有返回值不同的函数不能构成重载。
2. 覆盖：两个函数分别在基类和子类里，基类中的函数必须是虚函数，子类必须重写父类的方法。
   注意：基类和子类的两个函数都是虚函数。虽然子类重写父类的虚函数时有时候不加virtual,但子类的函数也是虚函数。
3. 重定义：两个函数分别在子类和父类，两函数的函数名相同，在继承中，子类会隐藏父类的方法。
   注意：
   （1）如果派生类的函数与基类的函数同名，参数不相同，此时，不论有无virtual关键字，基类的函数都将被隐藏。
   （2）如果派生类的函数与基类的函数同名，但是参数相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏。

二、代码演示

1. 函数重载：

class Base
{
public:
	int fun(int a, int b)
	{
		return a + b;
	}
	double fun(int a, double b)
	{
		return a + b;
	}
};

int main()
{
	Base ba;
	int a = ba.fun(3, 4);
	cout << a << endl;
	double b = ba.fun(3, 4.0);
	cout << b << endl;

	return 0;
}

2. 覆盖

如下方代码所示：

class Base
{

public:
	virtual void fun()
	{
		cout << "Base::fun()" << endl;
	}
	virtual void print()
	{
		cout << "Base::fun()" << endl;
	}
};

class student : public Base
{
public:
	void fun()
	{
		cout << "student::fun()" << endl;
	}
	void print()
	{
		cout << "student::print()" << endl;
	}
};

int main()
{
	student st;
	Base* p = &st;
	p->fun();//调用的是子类重写的函数
	p->print();
	return 0;
}

3. 重定义（同名隐藏）

class Base
{
public:
	void fun()
	{
		cout << "Base::fun()" << endl;
	}

private:
	int _b = 1;
};

class A : public Base
{
public:
	void fun(int a)
	{
		cout << "A:fun()" << endl;
	}
private:
	int _a = 2;
};

int main()
{
	A a;
	a.fun(1);//必须要给定参数，父类函数同名隐藏
	a.Base::fun();//想要调用父类方法必须加限定
	return 0;
}

重载，覆盖，以及重定义在C++中应用广泛，在今后的学习和工作中会经常遇到。