C++基础之重载，重写和隐藏（十八）

news2024/12/27 12:53:47

一.重载

定义：发生在统一作用域中，函数名称相同，但是参数列表不同（包括参数的个数，参数类型，参数顺序）。

#include <iostream>

using std::cout;
using std::endl;

int add(int a,int b)
{
    cout<<"this is int add(int a,int b)"<<endl;
    return a+b;
}

double add(double a, double b)
{
    cout<<"this is double add(double a, double b)"<<endl;
    return a+b;
}

int add(int a,int b,int c)
{
    cout<<"this is int add(int a,int b,int c)"<<endl;
    return a+b+c;
}

int main()
{
    int a=1,b=2,c=3;
    cout<<"int add(int a,int b) = "<<add(a,b)<<endl;
    cout<<"int add(int a,int b,int c) = "<<add(a,b,c)<<endl;

    double aa=1.2,bb=2.2;
    cout<<"double add(double a, double b) = "<<add(aa,bb)<<endl;


}

二.重写（覆盖）

定义：发生在基类与派生类中，必须是虚函数，函数名相同，参数列表也相同。可以通过override关键字判断是否是重写函数。

#include <iostream>

using std::endl;
using std::cout;

class Base
{
private:
    int _ix;
public:
    Base(int x=0)
    :_ix(x)
    {
        cout<<"Base(int x=0)"<<endl;
    }
    ~Base()
    {
        cout<<"~Base()"<<endl;
    }
    virtual
    void print()const
    {
        cout<<"Base::_ix = "<<_ix<<endl;
    }
};

class Derived
:public Base
{
private:
    int _iy;
public:
    Derived(int x=0,int y=0)
    :Base(x)
    ,_iy(y)
    {
        cout<<"Derived(int x=0,int y=0)"<<endl;
    }
    ~Derived()
    {
        cout<<"~Derived()"<<endl;
    }
    //经过继承下来此时print也是虚函数
    void print()const
    {
        cout<<"Derived:: _iy = "<<_iy<<endl;
    }

};
void func(Base* base)
{
    base->print();
}
void test()
{
    Base base(3);
    Derived derived(33,44);

    //同一个指令根据
    func(&base);
    func((Base*)&derived);
    func(&derived);  
}
int main()
{
    test();
    return 0;
}

如果加了override表示这个函数是继承基类的虚函数并且重写了基类的函数，因为重写时要保证函数名，函数类型，函数参数要完全相同，如果不同就会报错。

三.隐藏

定义：发生在基类与派生类中，派生类中的函数与基类的函数名字相同。（至于是不是虚函数，参数列表相不相同都没有关系），在派生类中会隐藏基类的同名函数和数据成员。

#include <iostream>
#include <string.h>
#include <stdio.h>
using std::cout;
using std::endl;

class Base
{
public:
    char* _str;
    Base(const char* str)
    :_str(new char[strlen(str)+1]())
    {
        strcpy(_str,str);
        cout<<"Base(const char* str)"<<endl;
    }
    virtual
    ~Base()
    {
        cout<<"~Base()"<<endl;
        if(_str)
        {
            delete[]_str;
            _str=nullptr;
        }
    }

    void print() const
    {
        printf("Base::_str = %s\n",_str);
    }
};

class Derived
:public Base
{
private:
    char* _str;

public:
    Derived(const char* str,const char* str1)
    :Base(str)
    ,_str(new char[strlen(str1)+1]())
    {
        strcpy(_str,str1);
        cout<<"Derived(const char* str,const char* str1)"<<endl;
    }

    ~Derived()
    {
        cout<<"~Derived()"<<endl;
        if(_str)
        {
            delete[]_str;
            _str=nullptr;
        }
    }

    void print() const
    {
        printf("Derived::_str = %s\n",_str);
        //同名的数据成员也会被隐藏，如果要找到基类的数据成员需要特指加上作用域限定符
        printf("Derived::Base::_str = %s\n",Base::_str);

    }


};
int main()
{
    Derived derived("基类","派生类");
    derived.print();
    //如果想要打印基类只能加上作用域限定符
    derived.Base::print();

}