抽象类

纯虚函数：

class A
{
    public:
        virtual void fun(){cout<<"A"<<endl;}
        virtual void fun_2() = 0;
        {
            cout<<"virtual_A"<<endl;
        }
    private:
        int a;
};

含有纯虚函数的的类——抽象类。（是含有，不是说类中只能存在纯虚函数）

class A
{
    public:
        virtual void fun(){cout<<"A"<<endl;}
        virtual void fun_2() = 0;
        {
            cout<<"virtual_A"<<endl;
        }
        virtual void fun_3() = 0;
    private:
        int a;
};

class B :public A
{
    public:
        B()
        {
            cout<<"B"<<endl;
        }
        void fun(){cout<<"B"<<endl;}
        virtual void fun_3()
        {
            cout<<"virtual_B"<<endl;
        }
    private:
        int c;
};

纯虚函数在派生类中被实现，只有类中所有纯虚函数被实现了之后才能被实例化——定义对象。

抽象类的意义：

因为抽象类提供了纯虚函数，它是一个公共接口，抽象类自身不定义实现，而是把实现丢给它的子类。这样可以通过父类指针的多态去调用不同的实现。

class A
{
    public:
        virtual void fun()=0;
    private:
        int a;
};


class B :public A
{
    public:
        void fun(){cout<<"B"<<endl;}
    private:
        int c;
};

void main()
{
    A *p = new B();
    p->fun();
}

 

多继承的真正应用场景：抽象类的多继承

#include "iostream"
using namespace std;

class Interface1
{
public:
    virtual void print() = 0;
    virtual int add(int i, int j) = 0;
};

class Interface2
{
public:
    virtual int add(int i, int j) = 0;
    virtual int minus(int i, int j) = 0;
};

class parent
{
public:
    int i;
};
class Child : public parent, public Interface1, public Interface2
{
public:  
    void print()
    {
        cout<<"Child::print"<<endl;
    }

    int add(int i, int j)
    {
        return i + j;
    }

    int minus(int i, int j)
    {
        return i - j;
    }
};

int main()
{
    Child c;

    c.print();

    cout<<c.add(3, 5)<<endl;
    cout<<c.minus(4, 6)<<endl;

    Interface1* i1 = &c;
    Interface2* i2 = &c;

    cout<<i1->add(7, 8)<<endl;
    cout<<i2->add(7, 8)<<endl;
    system("pause");
}