C++ 中重写重载和隐藏的区别

发布于:2024-05-16 ⋅ 阅读:(21) ⋅ 点赞:(0)

重写(override)、重载(overload)和隐藏(overwrite)在C++中是3个完全不同的概念。我们这里对其进行详细的说明

1、重写(override)是指派生类覆盖了基类的虚函数,这里的覆盖必须满足有相同的函数签名和返回类型,也就是说有相同的函数名、形参列表以及返回类型。

2、重载(overload)是指C++允许在同一作用域中声明几个功能类似的同名函数,这些函数的函数名相同,但是函数签名不同,也就是说有不同的形参。

3、隐藏(overwrite)是指基类成员函数,无论它是否为虚函数,当派生类出现同名函数时,如果派生类函数签名不同于基类函数,则基类函数会被隐藏。如果派生类函数签名与基类函数相同,则需要确定基类函数是否为虚函数,如果是虚函数,则这里的概念就是重写;否则基类函数也会被隐藏。另外,如果还想使用基类函数,可以使用using关键字将其引入派生类。

一、重写

函数重写的基本原则:在基类中,通过使用关键字 virtual 来声明一个虚函数,派生类可以通过重新定义基类中的虚函数来实现函数重写。

例如:

class Father {
public:
     virtual void func() {
        cout << "Father" << endl;
    }
};

class Child: public Father {
public:
    void func() {
        cout << "Child" << endl;
    }
};

int main() {
    Father f;
    Child c;
    f.func();
    c.func();
}

以上代码实现了子类重写父类中的函数。所以父类子类调用同一个函数会有不同的实现。仿真如下:

image-20240515164906765

1.1、重写引发的问题

重写虚函数很容易出现错误,原因是C++语法对重写的要求很高,稍不注意就会无法重写基类虚函数。且这些错误不易被发现,编译器可能也不会提示:

class Base {
public:
    virtual void some_func() {}
    virtual void foo(int x) {}
    virtual void bar() const {}
    void baz() {}
};

class Derived : public Base {
public:
    virtual void sone_func() {}
    virtual void foo(int &x) {}
    virtual void bar() {}
    virtual void baz() {}
};

Derived的4个函数都没有触发重写操作。第一个派生类虚函数sone_func的函数名与基类虚函数some_func不同,所以它不是重写。第二个派生类虚函数foo(int &x)的形参列表与基类虚函数foo(int x)不同,所以同样不是重写。第三个派生类虚函数bar()相对于基类虚函数少了常量属性,所以不是重写。最后的基类成员函数baz根本不是虚函数,所以派生类的baz函数也不是重写。

1.2、使用override说明符

重写容易出错,尤其继承关系非常复杂的时候。所以C++11标准提供了一个非常实用的override说明符,明确告诉编译器这个虚函数需要覆盖基类的虚函数,一旦编译器发现该虚函数不符合重写规则,就会给出错误提示。

class Derived : public Base {
public:
    virtual void sone_func() override {}
    virtual void foo(int &x) override {}
    virtual void bar() override {}
    virtual void baz() override {}
};

如果没有override说明符,则修改基类虚函数将面临很大的风险,因为编译器不会给出错误提示,我们只能靠测试来检查问题所在。

1.3、使用final说明符

可以为基类声明纯虚函数来迫使派生类继承并且重写这个纯虚函数。但是一直以来,C++标准并没有提供一种方法来阻止派生类去继承基类的虚函数。C++11标准引入final说明符解决了上述问题,它告诉编译器该虚函数不能被派生类重写。final说明符也需要声明在虚函数的尾部。

class Father {
public:
     virtual void func() final {
        cout << "Father" << endl;
    }
};

class Child: public Father {
public:
	// 报错,不能重写final修饰的函数
    void func() {
        cout << "Child" << endl;
    }
};

最后要说明的是,final说明符不仅能声明虚函数,还可以声明类。如果在类定义的时候声明了final,那么这个类将不能作为基类被其他类继承

class Base final {
public:
    virtual void foo(int x) {}
};

// 报错,不能继承final修饰的类
class Derived : public Base {
public:
    void foo(int x) {};
};

1.4、override和final的特别之处

在C++11标准中,override和final并没有被作为保留的关键字,其中override只有在虚函数尾部才有意义,而final只有在虚函数尾部以及类声明的时候才有意义,因此以下代码仍然可以编译通过:

void override() {}
void final() {}

二、重载

函数重载的条件:

1、参数个数不同

2、参数类型不同

3、参数顺序不同

void fun(int i) {
	cout << "打印整数: " << i << endl;
}
void fun(int i, int j) {
	cout << "打印两个整数: " << i << " 和 " << j << endl;
}
void fun(float f) {
	cout << "打印浮点数: " << f <<endl;
}

fun(4);				// 调用第一个 fun 函数  
fun(2, 3);			// 调用第二个 fun 函数
fun(1.5f);          // 调用第三个 fun 函数  

**注意:**返回值不同不是函数重载的判断标准

void fun(int i) {
	cout << "打印整数: " << i << endl;
}

int fun(int i) {
	cout << "打印整数: " << i << endl;
	return 0;
}

fun(4);             // 报错,并不知道调用哪个函数

2.1、函数重载的底层原理

为什么C++支持函数重载而C不支持?C语言中同名函数编译完还是同名的,两个重名函数的地址都是有效值,所以在重定位的时候就会产生冲突和歧义。而C++会对函数名进行修饰,例如:

void f(int a, double b) { printf("%d %lld", a, b) }

函数名 f 会被修正为 _Z1fid,Linux下的命名规则为

函数名被修饰为:_Z + 函数名长度 + 函数名 + 各个形参类型首字母的小写

这也就解释了为什么函数重载和返回值无关,为什么和参数个数,类型,顺序不同就可以重载,因为他们修饰完后的函数名就是不同的。

三、隐藏

隐藏指在某些情况下,派生类中的函数屏蔽了基类中的同名函数:

1、两个函数参数相同,但是基类不是虚函数。和重写的区别在于基类函数是否是虚函数

2、两个函数参数列表不同,无论基类函数是否虚函数,基类函数都将被覆盖。和重载的区别在于两个函数不在同一个类中

下面举例说明:

class Base {
public:
	void funA(){cout<<"funA()"<<endl;}
	virtual void funB(){cout<<"funB()"<<endl;} 
};

class Heri:public Base {
public:
    // 隐藏,基类中同名函数不是虚函数
	void funA(){cout<<"funA():Heri"<<endl;}
    // 隐藏,参数列表不同,无论基类是否是虚函数,基类函数都将被覆盖
	void funA(int a){cout<<"funA(int a):heri"<<a<<endl;}
    // 重写,基类是虚函数
	void funB(){cout<<"funB():heri"<<endl;}
};

隐藏使用的时候记住一句,派生类的指针或引用,对象调用子类和父类同名的函数,父类的同名函数被子类隐藏,调用的是子类的函数

看下面代码:

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

class Deriverd:public Base {
public:
    virtual void fun1() { cout<<"deriverd:fun1()"<<endl; }
    void fun() { cout<<"deriverd:fun()"<<endl; }
};

int main() {
    Base *pb = new Deriverd;
    pb->fun1();
    return 0;
}

输出结果为:

image-20240515173641206

main函数中创建了父类的指针指向了子类的对象,然后通过父类的指针调用具有隐藏关系的fun1()函数,我们会以为pb->fun1()调用的是子类的函数fun1(),实际并不是,隐藏关系的函数,谁调用就用谁的函数,按照正常的函数调用使用便可得正确的结果,这里是父类指针调用,就用父类的函数fun1()。这就是隐藏和重写的区别。

四、重写与隐藏的区别

看下面的代码:

class Base {
public:
    virtual void foo(int x) { cout << "Base: " << x << endl;}
    void foo(int x, int y) { cout << "Base: " << x << ' ' << y << endl; }
};

// 报错,不能继承final修饰的类
class Derived : public Base {
public:
    void foo(int x) { cout << x << endl; };
    void foo(int x, int y) {cout << x << ' ' << y << endl; }
};
int main() {
    Base *pb = new Derived;
    pb->foo(1);
    pb->foo(1, 2);

    return 0;
}

image-20240515174346499

其中 foo(int x, int y) 函数发生了隐藏,void foo(int x)函数发生了重写, Base *pb = new Derived;发生了父类指针指向子类对象,隐藏由于是父类指针,所以调用了父类的实现,重写由于是子类对象,所以调用了子类实现。


网站公告

今日签到

点亮在社区的每一天
去签到