多态

重载重写和隐藏

 1 #include <iostream>
 2 using namespace std;
 3 void Func(int a)
 4 {
 5     cout<<a<<endl;
 6 }
 7 void Func(int* a)//重载：函数名相同，参数不同
 8 {
 9     cout<<*a<<endl;
10 }
11 class CFather
12 {
13 public :
14     int m_a;
15     int m_b;
16     void Func(int a)
17     {
18         cout<<"CFather::Func()"<<endl;
19     }
20 };
21 class CSon:public CFather
22 {
23 public:
24     void Func(int b)//重写：子类与父类函数名相同，参数相同
25     {
26         cout<<"重写：CSon::Func()"<<endl;
27     }
28     void Func(int*a)//隐藏:子类与父类函数名相同，参数不同
29     {
30         cout<<"重载；CSon::Func()"<<endl;
31     }
32 };
33 int main()
34 {
35     CSon son;
36     int a = 0;
37     Func(a);
38     Func(&a);//重载
39     son.Func(&a);//隐藏：  只能调用子类中的函数
40     son.CFather::Func(a);//若要用父类中的函数要加作用域
41     son.Func(a);//重写
42 }

结果如图：

父类指针指向子类对象

#include <iostream>
using namespace std;

class CFather
{
public :
    int m_a;
    CFather()
    {
        m_a = 0;
    }
    void show()
    {
        cout<<"Father"<<endl;
    }
};
class CSon:public CFather
{
public:
    int m_a;
    int m_b;
    CSon()
    {
        m_a = 0;
        m_b = 0;
    }
    void show()
    {
        cout<<"Son"<<endl;
    }
};
int main()
{
    CFather *Father = new CSon;
    cout<<Father->m_a<<endl;
    Father->show();
    //cout<<Father->m_b<<endl; 不可以，父类指针只能调用父类包含的成员变量和函数
}

结果如图：

• 多态

虚函数实现多态

#include<iostream>
using namespace std;

class CWater
{
public:
    virtual void Show()   //  虚函数  通过父类的指针 调用子类的函数
    {
        cout << "CWater::Show" << endl;
    }
};

class CMilk : public CWater
{
public:
    void Show()
    {
        cout << "CMilk::Show" << endl;
    }
};

class CCoco: public CWater
{
public:
    void Show()
    {
        cout << "CCoco::Show" << endl;
    }
};

class CBeer: public CWater
{
public:
    void Show()
    {
        cout << "CBeer::Show" << endl;
    }
};

class CCoffee : public CWater
{
public:
    void Show()
    {
        cout << "CCoffee::Show" << endl;
    }
};

void Bottle(CWater* water)
{
    water->Show();
}

int main()
{

    /*CMilk* p1 = new CMilk;
    CCoco* p2 = new CCoco;
    CBeer* p3 = new CBeer;
    CCoffee* p4 = new CCoffee;*/

    CWater* p1 = new CMilk;
    CWater* p2 = new CCoco;
    CWater* p3 = new CBeer;
    CWater* p4 = new CCoffee;

    Bottle(p1);
    Bottle(p2);
    Bottle(p3);
    Bottle(p4);

    system("pause");
    return 0;
}

 结果如图：

多态的原理

#include<iostream>
using namespace std;


class CWater
{
public:
    virtual void AA() 
    {
        cout << "CWater::AA" << endl;
    }
    virtual void BB() 
    {
        cout << "CWater::BB" << endl;
    }
    void CC() 
    {
        cout << "CWater::CC" << endl;
    }
};

class CCoffee : public CWater
{
public:
    virtual void AA()
    {
        cout << "CCoffee::Show" << endl;
    }
    void DD() 
    {
        cout << "CCoffee::CC" << endl;
    }
};


int main()
{

    cout << sizeof(CWater) << endl;

    CWater* p = new CWater;
    p->AA();
    p->BB();

    p = new CCoffee;
    p->AA();
    p->BB();
    p->CC();

    system("pause");
    return 0;
}

结果如图：

　　　　

虚函数列表；

 纯虚函数，虚析构

#include <iostream>
using namespace std;

class CJT
{
public:
    virtual void Run()=0;//纯虚函数，没有大括号且将值赋为0
    CJT()
    {
        cout<<"CJT"<<endl;
    }    
    //~CJT()
    //{
    //    cout<<"~CJT"<<endl;
    //}
    virtual ~CJT()//虚析构函数通过父类的指针删除子类对象，通俗来讲可以在delete父类指针的时候调用子类的析构函数
    {
        cout<<"~CJT"<<endl;
    }

};
class CCar :public CJT
{
public:
    virtual void Run()
    {
        cout << "汽油" << endl;
    }
    CCar()
    {
        cout<<"CCar"<<endl;
    }
    ~CCar()
    {
        cout<<"~CCar"<<endl;
    }
};
class CBus :public CJT
{
public:
    virtual void Run()
    {
        cout << "电动" << endl;
    }
};
class CPlane :public CJT
{
public:
    virtual void Run()
    {
        cout << "飞机有" << endl;
    }
};

class CPerson
{
public:
    void Play(CJT* p)
    {
        cout << "张个大嘴" << endl;
        p->Run();
        cout << "好喝" << endl;

        delete p;
    }
};


int main()
{
    CPerson ps;

    /*CCar* car = new CCar;
    CBus* bus = new CBus;
    CPlane* plane = new CPlane;

    ps.Play(car);
    ps.Play(bus);
    ps.Play(plane);*/

    CJT * p = new CCar;
    delete p ;


    system("pause");
    return 0;
}

结果如图：

 成员静态变量

#include <iostream>
using namespace std;

class CPerson
{
public:
    static int n;   // 编译期存在
    //static const int a = 99;
    int m_nAge;
public:
    static void Show()  //  static函数 不能使用非static成员   因为static 函数中 没有this
    {
        //cout << m_nAge << endl;
        cout << n << endl;
    }
};
int CPerson::n = 100;   //  static 一定要在类外初始化

int main()
{

    cout << CPerson::n << endl;  //  static 成员  可以直接用类名作用 取得
    CPerson::Show();

    CPerson ps;
    cout << ps.n << endl;


    system("pause");
    return 0;
}