c++三大概念要分清--重载，隐藏（重定义），覆盖（重写）

最新推荐文章于 2024-03-03 09:00:34 发布

weixin_30696427

最新推荐文章于 2024-03-03 09:00:34 发布

阅读量63

点赞数

文章标签： c/c++

原文链接：http://www.cnblogs.com/linuxAndMcu/p/10292417.html

版权

重载，隐藏（重定义），覆盖（重写）—这几个名词看着好像很像，不过其实一样都不一样！！

综述：

è¿éåå¾çæè¿°

一、重载

（1）概念：在同一个作用域内；函数名相同，参数列表不同（参数个数不同，或者参数类型不同，或者参数个数和参数类型都不同），返回值类型可相同也可不同；这种情况叫做c++的重载！

（2）特征：

相同的范围（在同一个类中）。
函数名字相同。
参数列表不同。
virtual关键字可有可无。

（3）举例：

#include "stdafx.h"
#include<iostream> 

using namespace std;

int Add(int a, int b)
{
    return a + b;
}

float Add(float a, float b)
{
    return a + b;
}

int main()
{
    cout << Add(4, 5) << endl;//调用 int Add(int a,int b)
    cout << Add(2.5f, 3.7f) << endl;//调用 float Add(float a,float b)

    return 0;
}

/*
输出结果：

9
6.2
*/

此时，两个函数Add();在同一作用域，函数名相同都是Add，参数类型不同，就构成了c++中的函数重载。

（4）总结：c++函数重载达到的效果：调用函数名相同的函数，会根据实参的类型和实参顺序以及实参个数选择相应的函数。c++函数重载是一种静态多态（又叫做静态联编，静态绑定，静态决议）。

二、覆盖（又叫重写）

（1）概念：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写（也称覆盖）了父类的这个虚函数。

（2）覆盖：

不同的范围（分别位于派生类与基类）。
函数名字相同。
参数相同。
基类函数必须有virtual关键字。

（2）什么是在子类中定义了一个与父类完全相同的虚函数：

有两种情况：

1.就是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型，返回值类型都相同；这种情况下子类的这个虚函数重写的父类中的虚函数，构成了重写。
2.协变—是说子类中的虚函数和父类中的虚函数，函数名，参数个数，参数类型都相同，只是返回值类型不同；父类的虚函数返回父类的指针或者引用，子类虚函数返回子类的指针或者引用；这种情况下子类的这个虚函数也重写了父类中的虚函数，也构成了重写；——我们把这种特殊的情况叫做协变。

（3）覆盖（重写）达到的效果：

1.在子类中重写了父类的虚函数，那么子类对象调用该重写函数，调用到的是子类内部重写的虚函数，而并不是从父类继承下来的虚函数；（这其实就是动态多态的实现）；
2.在子类中重写了父类的虚函数，如果用一个父类的指针（或引用）指向（或引用）子类对象，那么这个父类的指针或引用将调用该子类重写的虚函数；相反，如果用一个父类的指针（或引用）指向（或引用）父类的对象，那么这个父类的指针或引用将调用父类的虚函数

（4）举例一：普通重写+函数重载

//普通重写+函数重载
#include "stdafx.h"
#include<iostream> 
using namespace std;

class Base
{
public:
    virtual void Print()//父类虚函数
    {
        printf("This is Class Base!\n");
    }
};

class Derived1 :public Base
{
public:
    void Print()//子类1虚函数，重写了父类的虚函数
    {
        printf("This is Class Derived1!\n");
    }
};

class Derived2 :public Base
{
public:
    void Print()//子类2虚函数，重写了父类的虚函数
    {
        printf("This is Class Derived2!\n");
    }
};

int main()
{
    Base Cbase;
    Derived1 Cderived1;
    Derived2 Cderived2;
    Cbase.Print();
    Cderived1.Print();
    Cderived2.Print();

    cout << "---------------" << endl;
    Base *p1 = &Cbase;
    Base *p2 = &Cderived1;
    Base *p3 = &Cderived2;
    p1->Print();
    p2->Print();
    p3->Print();
}

/*
输出结果：

This is Class Base!
This is Class Derived1!
This is Class Derived2!
---------------
This is Class Base!
This is Class Derived1!
This is Class Derived2!
*/

举例二：协变重写+函数重载

//（协变）重写+函数重载
#include "stdafx.h"
#include<iostream> 
using namespace std;

class Base
{
public:
    virtual Base &Print()//父类虚函数
    {
        printf("This is Class Base!\n");
        return *this;
    }
};

class Derived1 :public Base
{
public:
    Derived1 &Print()//子类1虚函数，重写了父类的虚函数
    {
        printf("This is Class Derived1!\n");
        return *this;
    }
};

class Derived2 :public Base
{
public:
    Derived2 &Print()//子类2虚函数，重写了父类的虚函数
    {
        printf("This is Class Derived2!\n");
        return *this;
    }
};

int main()
{
    Base Cbase;
    Derived1 Cderived1;
    Derived2 Cderived2;
    Cbase.Print();
    Cderived1.Print();
    Cderived2.Print();

    cout << "---------------" << endl;
    Base *p1 = &Cbase;
    Base *p2 = &Cderived1;
    Base *p3 = &Cderived2;
    p1->Print();
    p2->Print();
    p3->Print();
}

/*
输出结果：

This is Class Base!
This is Class Derived1!
This is Class Derived2!
---------------
This is Class Base!
This is Class Derived1!
This is Class Derived2!
*/

（5）总结：覆盖（重写）的两个必要条件：父类函数为虚函数，并且父类和子类函数的函数名、参数个数、参数类型等都必须相同。

三、隐藏（重定义）

（1）概念：是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

如果派生类的函数与基类的函数同名，但是参数不同，则不论有无virtual关键字，基类的函数都将被隐藏。
如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字，此时基类的函数被隐藏。

在调用一个类的成员函数时，编译器会沿着类的继承链逐级地向上查找函数的定义，如果找到了就停止查找了。所以，如果一个派生类和一个基类都存在同名（暂且不论参数是否相同）的函数，而编译器最终选择了在派生类中的函数，那么就说这个派生类的成员函数“隐藏”了基类的成员函数，也就是说它阻止了编译器继续向上查找函数的定义。

（2）特征：

必须分别位于派生类和基类中。
必须同名。
参数不同的时候本身已经不构成覆盖关系了，所以此时是否是virtual函数已经不重要了。

（2）隐藏（重定义）的使用范围：

隐藏的不光是类的成员函数，还可以是类的成员变量；

（3）隐藏（重定义）的直接效果：

如果在父类和子类中有相同名字的成员，那么在子类中，会将父类的成员隐藏；隐藏以后的直接效果就是：无论在子类的内部或者外部（通过子类成员）访问该成员；全都是访问子类的同名成员；如果在子类内部或者外部（通过子类成员）访问同名的成员函数，则需要根据函数调用的规则来调用子类的同名成员函数；否则调用失败。

（4）举例：

#include "stdafx.h"
#include<iostream> 
using namespace std;

class Base
{
public:
    Base(int x=1) :value(x) {}

    void Print1()//父类函数不是虚函数
    {
        cout << "Base Print1():" << value << endl;
    }

    virtual void printf2()//父类函数是虚函数
    {
        cout << "Base Print2():" << value << endl;
    }

    int value;
};

class Derived :public Base
{
public:
    Derived(int x=2) :value(x) {}

    void Print1()//父类函数不是虚函数，则同名子类函数不管相不相同，都可构成“隐藏”
    {
        cout << "Derived Print1():" << value << endl;
    }

    void Print2(int a)//父类函数是虚函数，则同名子类函数必须不完全相同，才构成“隐藏”，否则就是“重载”
    {
        cout << "Derived Print2():" << value << endl;
        a = 0;
    }

    int value;//子类成员数据，隐藏了子类的同名数据
};

int main()
{
    Derived Cderived;
    cout << Cderived.value << endl; //调用子类的成员数据
    Cderived.Print1(); //调用子类的Print1()函数
    Cderived.Print2(1); //调用子类的Print2()函数
}

/*
输出结果：

2
Derived Print1():2
Derived Print2():2
*/

（5）总结：注意覆盖（重写）和隐藏（重定义）不要搞混了。

四、重载与覆盖(重写)有什么区别？

(1) 范围区别：重载的函数在同一类中，而重写的函数在不同的类（基类和派生类）中。

(2) 参数列表区别：重载要求参数列表不同，而覆盖要求参数列表相同。

(3) virtual的区别：重载函数和被重载函数可以被virtual修饰，也可以没有，而重写的基类函数必须要有virtual修饰。

(4) 调用方法不同：重载是根据调用时的实参列表来选择方法体的，而覆盖是根据对象的类型来决定的。

程序示例如下：

#include <iostream> 
using namespace std;

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

class Derived:public Base
{
public:
    virtual void g(void)
    {
        cout<<"Derived::g(void)"<<endl;
    }
}；

int main()
{
    Derived d;
    Base *pb = &d; 
    pb->f(42);
    pb->f(3.14f);
    Pb->g(); 
    
    return 0;
}

/*
输出结果：

Base::f(int) 42 
Base::f(float) 3.14 
Derived: :g(void)
*/

上例中，函数 Base::f(int)与 Base::f(float)相互重载，而 Base::g(void)被 Derived::g(void)覆盖。

五、隐藏(重定义)与覆盖(重写)有什么区别？

(1) virtual的区别：隐藏的基类函数不需要用virtual修饰，而覆盖的基类函数必须要有virtual修饰。

(2) 参数列表区别：隐藏的基类和派生类的函数参数列表可以不同，而覆盖的基类和派生类的函数参数列表必须相同。

示例程序如下：

#include <iostream> 
using namespace std;

class Base
{
public:
    virtual float f(float x)
    {
        cout<<"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 Derived:public Base
{
public:
    virtual float f(float x)
    {
        cout<<"Derived::f(float) "<<x<<endl;
    }

    void g(int x)
    {
        cout<<"Derived::g(int) "<<x<<endl;
    }   

    void h(float x)
    {
        cout<<"Derived::h(float) "<<x<<endl;
    }
};

int main()
{
    Derived d;
    Base *pb = &d;
    Derived *pd = &d;
    pb->f(3.14f);
    pd->f(3.14f);
    pb->g(3.14f);
    pd->h(3.14f);
    
    return 0;
}

/*
输出结果：

Derived::f(float) 3.14 
Derived::f(float) 3.14 
Base::g(float) 3.14 
Derived::h(float) 3.14
*/

上例中，函数 Derived: :f(float)覆盖了 Base: :f(float)，函数 Derived: :g(int)隐藏了 Base: :g(float)；函数Derived::h(float)隐藏了 Base::h(float)。

参考：

gogogo_sky

转载于:https://www.cnblogs.com/linuxAndMcu/p/10292417.html

weixin_30696427

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
c++三大概念要分清--重载，隐藏（重定义），覆盖（重写）

重载，隐藏（重定义），覆盖（重写）—这几个名词看着好像很像，不过其实一样都不一样！！综述：一、重载（1）概念：在同一个作用域内；函数名相同，参数列表不同（参数个数不同，或者参数类型不同，或者参数个数和参数类型都不同），返回值类型可相同也可不同；这种情况叫做c++的重载！（2）特征：相同的范围（在同一个类中）。函数名字相同。参数列表不同。virtual关键字可有可无。（3）...
复制链接

扫一扫