C/C++面试：成员函数的重载、继承、覆盖、隐藏_c++ 面试虚函数重载-优快云博客

1、成员函数的重载

1.1、C++中的成员函数有4种，分别是普通成员函数，virtual虚函数，const成员函数。

void func(int a)
virtual void func(int a);
void func(int a) const;

如果在一个类中，声明这四种函数，哪是重复定义？哪些是重载？其中(1)(2)是重复定义，故编译不能通过，而(3)与(1)(2)是不同类型的函数，是重载。

因为类中的函数，都会自动添加一个自身类指针this，所以

void func(int a); ------> void func(Base *this, int a)
virtual void func(int a); ------> virtual void func(Base *this, int a)
void func(int a) const; ------> void func(const Base *this, int a) const

所以(3)可以和(1)(2)重载，因为参数有一个const

1.2、类的成员函数重载是在同一个类中有多个同名的方法，这些方法的参数类型、参数个数或者方法属性(const)不同。

#define _CRT_SRCURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;

class MyClass
{
public:
	MyClass(int a = 0):c(a) {};
	void go(int a) { cout << "go "; };
	void go(char a){ cout << "char go "; };
	void print()const//函数体中不能修改数据成员对象，否则报错
	{
		cout << "const " << c << endl;
	}
	void print()//函数体中可修改成员对象
	{
		c = 23;
		cout << "non-const " << c << endl;
	}
private:
	int c;
};
void main()
{
	MyClass my;
	my.go(1);
	my.print();  //non-const  23
	
	const MyClass myC;
	myC.print();  //const 0
	system("pause");
}

成员函数重载特征：

相同的范围
函数名字相同
参数类型，个数，顺序不同[包括const参数和非const参数]
virtual关键字可有可无

2、成员函数的继承

#define _CRT_SRCURE_NO_WARNINGS
#include <iostream>
using namespace std;

class Base
{
public:
	void func(int a) { cout << "Base::f(int a)" << endl; };
	virtual void go(int a) { cout << "virtual Base: go(int a) " << endl; }; //virtual void func(Base *this, int a)
};

class Deviced :public Base
{
public:
	void h(int a) { cout << "Deviced::h(int a)" << endl; };
};
void main()
{
	Base b;
	b.func(3);
	b.go(4);
	Deviced d;
	d.func(32);
	d.go(4);
	d.h(32);
	system("pause");
}

子类deviced d种继承了父类种的virtual void g(int a), vpid f(int a);

3、成员函数的覆盖

覆盖是指派生类重新实现[或者改写]基类地成员函数，其特征是：

不同的作用域
函数名称相同
参数列表相同
基类函数必须是虚函数----->覆盖是针对基函数的

Deviced d种重新定义了基类的虚函数成员virtual void g(int a);

#define _CRT_SRCURE_NO_WARNINGS
#include <iostream>
using namespace std;

class Base
{
public:
	void func(int a) { cout << "Base::f(int a)" << endl; };
	virtual void go(int a) { cout << "virtual Base: go(int a) " << endl; }; //virtual void func(Base *this, int a)
};

class Deviced :public Base
{
public:
	void h(int a) { cout << "Deviced::h(int a)" << endl; };
	virtual void go(int a) { cout << "Deviced Base: go(int a) " << endl; };
};
void main()
{
	Base b;
	b.func(3);
	b.go(4);
	Deviced d;
	d.func(32);
	d.go(4);
	d.h(32);
	system("pause");
}

4、成员函数的隐藏

隐藏是指派生类的成员函数遮蔽了与其同名的基类成员函数：隐藏是在子类中看不到父类的函数

隐藏/重定义：指的是派生类的成员函数隐藏了基类函数的成员函数。

在调用一个类的成员函数时候，编译器会沿着类的继承链逐步向上查找函数的定义，如果找到了就停止查找了。
如果一个派生类和一个基类都有同一个同名函数，而编译器最后选择了派生类的函数，我们就说这个派生类的成员函数隐藏了基类的成员函数，也就是阻止了编译器继续向上查找函数的定义。

#define _CRT_SRCURE_NO_WARNINGS
#include <iostream>
using namespace std;

class Base {
public:
	virtual void f(float x) { cout << "virtual Base::f(float)" << x << endl; }
	void g(float x) { cout << "Base::g(float)" << x << endl; }
    void h(float x) { cout << "Base::h(float)" << x << endl; }
};

class Deviced :public Base
{
public:
	virtual void f(float x) { cout << "virtual Deviced::f(float)" << x << endl; }
	void g(int x) { cout << "Deviced::g(int)" << x << endl; }
	/*派生类的函数与基类的函数同名不同参，此时，无论有无vritual，*/
	void h(float x) { cout << "Deviced::h(float)" << x << endl; }
};
void main()
{
	Deviced d;
	Base *pb = &d;   //基类指针指向派生类
	pb->f(3.14f);    //覆盖 
	/*virtual Deviced::f(float)：f是一个虚函数，派生类重写了这个虚函数
	不同的范围，函数名字相同，参数相同，是基函数
	派生类对象/指向派生类的指针：调用了子类的同名函数
	基类对象：调用基类中的函数
	*/
	pb->g(3.14f);     //Base::g(float)
	/*不同类中，不是重载；不是virtual不是覆盖，没关系
	基类指针只能访问基类g
	*/
	pb->h(3.14f);  //Base::h(float)
	Deviced *pd = &d;     //派生类指针调用派生对象 
	pd->f(3.14f);     //  virtual Deviced::f(float)
	pd->g(3.14f);     //Deviced::g(int)
	pd->h(3.14f);     //Deviced::h(float)，隐藏是在子类中看不到父类的函数
	system("pause");
}