overload override hide

一、重载(overload)

1.作用域相同；
2.函数名字相同；
3.函数参数不同 编译器生成的函数名字不同，名字粉碎】；
4.与 virtual 关键字无关；

void print(int a)
{cout<<"print(int): "<<a<<endl;}
void print(double a)
{cout<<"print(float): "<<a<<endl;}
class base
{
public:
    base(){cout<<"base's constructor\n";}
    ~base(){cout<<"base's destructor\n";}
    void print(int a)
    {cout<<"base::print(int): "<<a<<endl;}
    void print(double a)
    {cout<<"base::print(float): "<<a<<endl;}
private:
};

int main()
{
    print(1);
    print(1.56);

    base b1;
    b1.print(1);
    b1.print(1.56);

    (&b1)->print(1);
    (&b1)->print(1.56); 
    return 0;
}

二、隐藏(hide) :隐藏是指派生类的函数屏蔽了与其同名的基类函数
1.继承关系
2.函数名字相同；
3.函数参数不同 编译器生成的函数名字不同，名字粉碎】；
4.与 virtual 关键字无关，因为形成不了多态；

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

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

class base
{
public:
    base(){cout<<"base's constructor\n";}
    ~base(){cout<<"base's destructor\n";}
    void print(int a)
    {cout<<"base::print(int): "<<a<<endl;}

    virtual void add(int a,int b)
    { printf("base::[int] a[%d] + b[%d]=%d\n",a,b,a+b);}

    virtual void sub(int a,int b)
    { printf("base::[int] a[%d] - b[%d]=%d\n",a,b,a-b);}    
private:
};

class derived: public base
{
public:
    derived(){cout<<"derived's constructor\n";}
    ~derived(){cout<<"derived's destructor\n";}
    void print(double a)
    {cout<<"derived::print(float): "<<a<<endl;}

    virtual void add(double a,double b)
    { printf("derived::[double] a[%f] + b[%f]=%f\n",a,b,a+b);}

    virtual void sub(double *a,double *b)
    { printf("derived::[double*]  a[%f] - b[%f]=%f\n",*a,*b,*a-*b);}        
private:

};

int main()
{

    base b1;
    derived d1;
    double a=2.5,b=1.5;
    //int ia=2,ib=1;

    base *pbase=&b1;
    pbase->print(1);
    pbase->sub(2,1);

    pbase->print(1.0); 
    //pbase->sub(&a,&b);//error: invalid conversion from 'double*' to 'int'

cout<<"------------------------------\n";
    pbase=&d1;
    pbase->print(1);
    pbase->sub(2,1);

    pbase->print(1.0); 
    //pbase->sub(&a,&b);//error: invalid conversion from 'double*' to 'int'


cout<<"------------------------------\n";   

    ( (base*)(&d1) )->print(1);
    ( (base*)(&d1) )->sub(2.5,1.5); 

cout<<"------------------------------\n";   
    ( (derived*)(&d1) )->print(1);
    //( (derived*)(&d1) )->sub(2,1);// error: invalid conversion from 'int' to 'double*'    

    return 0;
}

三、覆盖(override)
1.继承关系
2.函数名字相同；
3.基类函数必须是 virtual 的，子类可有可无；
4.函数参数、返回值 相同；

class base
{
public:
    base(int i,int j):a(i),b(j)
    {cout<<"base's constructor\n";}
    ~base(){cout<<"base's destructor\n";}
    virtual void print(int )
    {cout<<"base::print(int): "<<a<<endl;}

    virtual void add(int )
    { printf("base::[int] a[%d] + b[%d]=%d\n",a,b,a+b);}

    virtual void sub(int )
    { printf("base::[int] a[%d] - b[%d]=%d\n",a,b,a-b);}    
private:
    int a,b;
};

class derived: public base
{
public:
    derived(double i,double j,int x,int y):base(x,y),a(i),b(j)
    {cout<<"derived's constructor\n";}
    ~derived(){cout<<"derived's destructor\n";}
    void print(int )
    {cout<<"derived::print(double): "<<a<<endl; }

    void add(int )
    { printf("derived::[double] a[%f] + b[%f]=%f\n",a,b,a+b);}

    void sub(int )
    { printf("derived::[double*]  a[%f] - b[%f]=%f\n",a,b,a-b);}        
private:
    double a,b;
};

int main()
{

    base b1(10,5);
    derived d1(10.9,2.9,10,5);
    double a=2.5,b=1.5;
    //int ia=2,ib=1;

    base *pbase=&b1;
    pbase->print(1);
    pbase->sub(2);

    pbase->print(1.0); 
    pbase->sub(a);

cout<<"------------------------------\n";
    pbase=&d1;
    pbase->print(1);
    pbase->sub(2);

    pbase->print(1.0); 
    pbase->sub(a);

cout<<"------------------------------\n";   

    ( (base*)(&d1) )->print(1);
    ( (base*)(&d1) )->sub(2.5); 

cout<<"------------------------------\n";   
    ( (derived*)(&d1) )->print(1);
    ( (derived*)(&d1) )->sub(2);

    return 0;
}

四、static function only can be hide and overload

class base
{
public: 
    base(int i,int j):a(i),b(j)
    {cout<<"base's constructor\n";}
    ~base(){cout<<"base's destructor\n";}

    //virtual static void printh(void)//error: member 'printh' cannot be declared both virtual and static
    //{ cout<<"hello world\n";}
    static void printh(void)
    { cout<<"base:: hello world\n";}    
private:
    int a,b;
};

class derived: public base
{
public:
    derived(double i,double j,int x,int y):base(x,y),a(i),b(j)
    {cout<<"derived's constructor\n";}
    ~derived(){cout<<"derived's destructor\n";}

    void printh(void)   
    { cout<<"derived:: hello world\n";}     
private:
    double a,b;
};

int main()
{

    base b1(10,5);
    derived d1(10.9,2.9,10,5);

    base *pbase=&b1;
    pbase->printh();
cout<<"------------------------------\n";

    pbase=&d1;
    pbase->printh();
cout<<"------------------------------\n";   

    ( (base*)(&d1) )->printh();
cout<<"------------------------------\n";   

    ( (derived*)(&d1) )->printh();
    return 0;
}