小谈C++的函数重载，成员函数覆盖与成员函数隐藏

拼搏现实的明天。 2022-03-15 12:36 176阅读 0赞

函数重载：

函数重载是指在同一作用域内，可以有一组具有相同函数名，不同参数列表的函数，这组函数被称为重载函数。在一个类内，可以将功能相似的函数进行重载，一方面方便调用，另一方面使得类简洁。注意同一作用域不单单指类作用域内的成员函数，非成员的全局函数也可以进行重载。

其规则为：相同的函数名，不同的参数列表。不同的参数列表包括参数的类型不同，和参数的数量不同两种。注意不同的返回值类型无法实现函数重载。重载函数与virtual关键字无关。

下面例子是一个函数重载的例子，包括类成员函数的重载和非成员函数重载。

\#include <iostream>

\#include <string>

using namespace std;

class Overload

public:

Overload()\{ adder = 0;\}

int add(int a);

int add(int a, int b);

string add(string a,string b);

private:

int adder;

\};

int Overload::add(int a)

adder += a;

return adder;

int Overload::add(int a, int b)

return a + b;

string Overload::add(string a, string b)

return a + b;

// 与void print()冲突，编译错误

//int print()

//\{

// cout << "Intprint!" << endl;

//\}

void print()

cout << "voidprint!" << endl;

void print(int para)

cout << "Theint para value is : " << para << endl;

void print(string para)

cout << "Thestring para value is : " << para << endl;

int main()

Overload overload;

print(overload.add(10));

print(overload.add(10,10));

print(overload.add("Hello ", "World!"));

print();

return 0;

运行结果：

The int paravalue is : 10

The int paravalue is : 20

The string paravalue is : Hello World!

void print!

上述代码中，add具有不同参数个数的重载函数，具有相同参数个数，不同参数类型的重载函数。注意：对于不同参数个数的重载函数，如果前面参数相同，而多出的参数不可以设置默认值，否则便也也是错误。如下例：

int add(int a);

int add(int a, int b = 0);

此时由于b有了默认值，对第二参数的调用则可以使用add(1)这样单个参数的形式进行调用，将产生歧义。

函数覆盖：

覆盖特指的子类函数覆盖或改写父类虚函数的情况。

1.不同的范围中(位于基类与派生类)

2.函数名字相同

3.参数相同

4.基类函数必须是virtual函数

这里实现的也就是C++中的动态绑定。将子类对象赋给父类指针或引用时，调用覆盖的函数，则调用子类的对应函数，实现动态绑定。而如果函数没有进行覆盖，则会调用父类的函数。如下实例进行说明：

\#include <iostream>

using namespace std;

class Base

public:

Base():a(1), b(2)\{\};

virtual void printa();

void print();

void printb();

protected:

int a;

int b;

\};

void Base::printa()

cout << "a :" << a << endl;

void Base::printb()

cout << "Base->> ";

cout << "b :" << b << endl;

cout << "Baseprintb call print a ->>";

printa();

void Base::print()

cout << "Baseclass!" << endl;

class Derived : public Base

public:

Derived()\{a = 11; b = 12;\}

virtual void printa();

void print(string b);

void printb();

\};

void Derived::printa()

cout << "a :" << a << endl;

void Derived::printb()

cout <<"Derived->> ";

cout << "b :" << b << endl;

cout <<"Derived printb call printa ->>";

void Derived::print(string b)

cout <<"Derived class!--" << b << endl;

int main()

Base \* base = newDerived();

base->printa();

base->printb();

base->print();

//base->print("Hello world");

return 0;

运行结果：

a : 11

Base->> b: 12

Base printb callprint a ->>a : 11

Base class!

解析：由于在基类中printa为虚函数，在子类中进行了覆盖，可以实现动态绑定，因此调用子类自己的printa函数，输出a : 11。

对于printb，由于它没有声明为virtual，因此它不会实现动态绑定，因此调用的是基类的printb函数，又因为在对成员函数进行调用时，需要默认传入this指针作为参数，由于此时base指针指向的是Derived的对象，因此它传入的也是自己所指向的对象的this指针，因此在printb里面打印出了 Base-> b:12的结果。！！！注意：其实C++中对成员函数已经通过C++的名字修饰的处理，将他们变为了类似全局函数的函数，所不同的是如果在函数中使用到了成员，则会为函数添加this指针作为隐式参数！！！

下面这一句则充分证明了虽然调用的是Base的printb，但是传入的是Derived的this指针，在printb中调用printa方法，由于此时传入的this指针为Derived对象的this指针，仍然发生动态绑定，打印的为a : 11

最后一句无需解释，上述解析明白之后，这个自然明白。

总结一句：如果使用virtual 关键字说明函数，则对函数的调用完全是根据调用时使用的类的类型来决定。如果用到了成员，则会想函数中传递this指针，this指针由当前的实际对象来决定。

注：由于父类对象无法赋给子类指针或引用，这样的赋值时违反C++的规则的。因此不存在子类指针指向的父类对象，在调用函数时传递给函数的为父类对象的情况出现。其他两种情况：父类指针指向父类对象，子类指针指向子类对象都不存在上述的问题。此处不再额外阐述。

隐藏：

这里的” 隐藏”是指派生类的函数屏蔽了与其同名的基类函数。

C++中的隐藏规则：

1.如果派生类的函数与基类函数名字相同，但是参数不同，不论有无virtual关键字，基类的函数将被隐藏。(注意不要与重载混淆)

2.如果派生类的函数与基类函数同名，并且参数也相同，但是基类函数没有virtual关键字，此时基类的函数被隐藏。(注意不要与覆盖混淆)

此处使用网上他人写的例子，没有记错应该是林锐的高质量C/C++编程中的代码。

\#include<iostream.h>

using namespace std;