【C++】面向对象类成员函数的重载、覆盖与隐藏

重载：

重载就是一个相同的作用域内实现相同的操作，但是操作的对象不相同

特征：

（1）成员函数重载：
（2）相同的范围（相同的作用域）
（3）函数名字相同
（4）参数不同（类型不同，个数不同，顺序不同）
注意：返回值类型不同不算函数重载

下面给出代码示例

#include <iostream>
using namespace std;

class father
{
public:
	void Add_int(int a, int b);
	void Add_double(double a, double b);
	void Add(int a);
};
void father::Add_int(int a, int b)
{
	cout << "Add_int(int a, int b)" << endl;
}
void father::Add_double(double a, double b)
{
	cout << "Add_double(int a, int b)" << endl;
}
void father::Add(int a)
{
	cout << "Add(int a, int b)" << endl;
}
int main()
{
	father f;
	f.Add(1);
	f.Add_double(1.0, 1.0);
	f.Add_int(1, 2);
	return 0;
}

运行结果

覆盖：

覆盖就是面向对象的多态，指的是派生类函数覆盖基类函数。

特征：

（1）不同的范围（不同的作用域，分别是基类和派生类）

（2）参数相同

（3）函数名字必须相同
（4）函数原型相同

（5）基类函数必须有virtual关键字

下面给出代码示例

#include <iostream>
using namespace std;
class father
{
public:
	virtual void Add_int(int a);
	void Add_double(double a);
};
void father::Add_int(int a)
{
	cout << "father:Add_int(int a)" << endl;
}
void father::Add_double(double a)
{
	cout << "father:Add_int(int a)" << endl;
}

class son :public father
{
public:
	void Add_int(int a);
};
void son::Add_int(int a)
{
	cout << "son:Add_int(int a)" << endl;
}

int main()
{
	son s;
	father *f = &s;
	f->Add_int(1);
	s.Add_int(1);
	s.Add_double(1);
	return 0;
}

运行结果

隐藏：

隐藏就是派生类函数屏蔽了它的基类的同名函数

特征：

（1）不同的范围（不同的作用域，分别是基类和派生类）

（2）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（3）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）这时添加virtual将隐藏换成覆盖

下面给出代码示例

#include <iostream>
using namespace std;

class father
{
public:
	void Add_int(int a);
	virtual void virtual_Add_int(int a);//基类有virtual关键字
	void Add_double(double a);
	virtual void Add_double(double a, double b);
};
void father::Add_int(int a)
{
	cout << "father:Add_int(int a)" << endl;
}
void father::virtual_Add_int(int a)
{
	cout << "father:virtual_Add_int(int a)" << endl;
}
void father::Add_double(double a)
{
	cout << "father:Add_double(double a)" << endl;
}
void father::Add_double(double a, double b)
{
	cout << "father:Add_double(double a, double b)" << endl;
}

class son :public father
{
public:
	void Add_int(int a,int b); // 与基类的函数同名,参数不同
	void virtual_Add_int(int a, int b);//有virtual与基类的函数同名,参数不同
	void Add_double(double a);//与基类的函数同名,参数也相同，基类函数没有virtual关键字。
	void Add_double(double a, double b);
};
void son::Add_int(int a, int b)
{
	cout << "son:Add_int(int a, int b)" << endl;
}
void son::virtual_Add_int(int a, int b)
{
	cout << "son:virtual_Add_int(int a, int b)" << endl;
}
void son::Add_double(double a)
{
	cout << "son:Add_double(double a)" << endl;
}
void son::Add_double(double a, double b)
{
	cout << "son:Add_double(double a, double b)" << endl;
}

int main()
{
	son s;
	s.Add_int(1, 2);
	//s.Add_int(1);显示调用参数少
	s.virtual_Add_int(1, 2);
	//s.virtual_Add_int(1);显示调用参数少
	s.Add_double(1.0);
	s.Add_double(1.0, 2.0);
	return 0;
}

运行结果