精华内容
下载资源
问答
  • Python的单继承和多继承,多重
    2021-03-17 17:31:50

    我们用两部分来写写Python的继承,分为单继承和多继承。在《流畅的Python》11和12章介绍了协议和抽象基类,以及继承的优点缺点,抽象基类这块真的很抽象…我觉得自己能看懂,却真的写不出来啥,乱写一通没有啥意思,我实在是写不好。我们就来写写继承好了,以及Python继承的一些调用方式。

    第一部分,单继承

    和C++的继承一样,子类可以继承父类的方法,我们从一个简单的例子说起

    class A():

    def fun(self):

    print('A class fun here')

    class B(A):

    pass

    b = B()

    b.fun()

    '''输出

    A class fun here

    '''

    就和我们预想的一样,虽然B类中没有fun()函数,但是因为B继承自A,所以可以调用A的fun()函数。那么如果我们在B里也定义fun()函数呢?

    class B(A):

    def fun(self):

    print('B class fun here')

    b = B()

    b.fun()

    '''输出

    B class fun here

    '''

    这样情况下将会优先调用子类的对应函数。但是我们仍然可以显示的去执行父类的函数,比如这样

    class A():

    def fun(self):

    print('A class fun here')

    class B(A):

    def fun(self):

    #这两种写法都是可以的

    super().fun()

    #super(B,self).fun()

    b = B()

    b.fun()

    '''输出

    A class fun here

    '''

    利用super()函数,我们可以选择调用父类的函数,很多时候我们都需要在子类的初始化函数中调用父类的初始化函数__init__()

    第二部分,多重继承

    结合单继承的几个例子,我们看看Python多继承是如何执行的

    class A():

    def fun(self):

    print('A class fun here')

    class B():

    def fun(self):

    print('B class fun here')

    class C(A,B):

    pass

    # class C(B,A):

    # pass

    c = C()

    c.fun()

    #输出 A class fun here

    此时C继承A和B,这个时候我们调用fun(),发现执行的是A的fun(),为什么不是B的呢?我们尝试把继承的顺序调换一下看看

    class A():

    def fun(self):

    print('A class fun here')

    class B():

    def fun(self):

    print('B class fun here')

    # class C(A,B):

    # pass

    class C(B,A):

    pass

    c = C()

    c.fun()

    #输出 B class fun here

    我们发现这个时候,执行的是B的fun(),看来到底执行那个父类的方法并不是随机的,是由什么东西控制的。其实关键就是一个叫做MRO的东西,我们看看下列代码

    class A():

    def fun(self):

    print('A class fun here')

    class B():

    def fun(self):

    print('B class fun here')

    class C1(A,B):

    pass

    class C2(B,A):

    pass

    print('C1 MRO',C1.__mro__)

    print('C2 MRO',C2.__mro__)

    C1().fun()

    C2().fun()

    '''输出

    C1 MRO (, , , )

    C2 MRO (, , , )

    A class fun here

    B class fun here

    '''

    在发现子类中没有对应方法后,开始在父类中寻找对应方法,寻找是按照一个顺序进行的,这个顺序就存放在类的__mro__成员变量中。(object是python中所有定义的类的超类,在python2中,自定义的类都要继承自object,python3中则不需要再显示的写出来,但是仍然会继承自object)

    关于Python的MRO,其实还有很多细节部分,是的,我完全写不了,,有兴趣了解的可以查看专门的介绍,另外,抽象类的继承还有更多的细节。

    第三部分,总结

    子类首先在自己的方法里找,若是找不到的话就会去继承的父类中找,单继承自然是去唯一的父类中找,若是多继承,则按照__mro__的顺序进行查找。

    虽然我进行了检查,但是也难免有出错,若有错误望指出

    更多相关内容
  • 继承和多重继承

    千次阅读 2021-03-08 16:19:32
    ------------------siwuxie095继承 多重继承,两个词差别不大,但是差之毫厘、谬以千里 …多重继承如果这样三个类:人类、士兵类、步兵类,其中:士兵类继承了人类,步兵类继承了士兵类,这三个类之间的关系...

    ------------------siwuxie095

    多继承 和 多重继承,两个词差别不大,但是差之毫厘、谬以千里 …

    多重继承

    如果有这样三个类:人类、士兵类、步兵类,其中:士兵类继承了人类,

    步兵类继承了士兵类,这三个类之间的关系称之为多重继承

    35dd1b4910c690ffb39c0d846d389af4.png

    如果在继承时,这三个类都使用了 public 公有继承,那么它们也

    存在着以下的关系:

    士兵是一个人,步兵是一个士兵,步兵也是一个人

    f87c343a299afda5873a8e115c190e6a.png

    具体到代码上,可以这样来写:

    ba5d4f34dbafb720d537409a56b7282f.png

    多继承

    如果有一个类,不仅继承了工人类,还继承了农民类,暂且把这个类

    称之为 农民工类

    即 一个子类同时有两个父类,或 一个派生类同时有两个基类,这样的

    关系称之为多继承

    fa23007637174b2c70b3b857f2ee68c9.png

    多继承和多重继承是完全不同的,在多继承的关系下,如果农民工类

    在继承工人类和农民类时,都以 public 公有继承的方式继承,那么

    它们还存在着这样一种关系:

    农民工是一个工人,农民工是一个农民,但工人和农民本身是平行的

    618b04dc8f52abde1eda12db0c1f9ac1.png

    具体到代码上,可以这样来写:

    cba105a2caa8fd138f6159b27792f62c.png

    注意:写法上,中间要加逗号隔开,在继承每一个类时,都要将继承

    方式写出来,如果不写,系统默认继承方式为 private 私有继承

    程序 1:多重继承

    Person.h:

    #include

    using namespacestd;

    classPerson

    {

    public:

    Person(string name = "Jim");

    ~Person();

    voidplay();

    protected:

    string m_strName;

    };

    Person.cpp:

    #include"Person.h"

    #include

    using namespacestd;

    Person::Person(string name)

    {

    m_strName = name;

    cout << "Person()"<< endl;

    }

    Person::~Person()

    {

    cout << "~Person()"<< endl;

    }

    voidPerson::play()

    {

    cout << "Person--play()"<< endl;

    cout << m_strName << endl;

    }

    Soldier.h:

    #include"Person.h"

    classSoldier:publicPerson

    {

    public:

    Soldier(string name = "James", intage = 20);

    ~Soldier();

    voidwork();

    protected:

    intm_iAge;

    };

    Soldier.cpp:

    #include"Soldier.h"

    #include

    using namespacestd;

    Soldier::Soldier(string name, intage)

    {

    m_strName = name;

    m_iAge = age;

    cout << "Soldier()"<< endl;

    }

    Soldier::~Soldier()

    {

    cout << "~Soldier()"<< endl;

    }

    voidSoldier::work()

    {

    cout << "Soldier--work()"<< endl;

    cout << m_strName << ","<< m_iAge << endl;

    }

    Infantry.h:

    #include"Soldier.h"

    classInfantry:publicSoldier

    {

    public:

    Infantry(string name = "Jack", intage = 30);

    ~Infantry();

    voidattack();

    };

    Infantry.cpp:

    #include"Infantry.h"

    #include

    using namespacestd;

    Infantry::Infantry(string name, intage)

    {

    m_strName = name;

    m_iAge = age;

    cout << "Ifantry()"<< endl;

    }

    Infantry::~Infantry()

    {

    cout << "~Infantry()"<< endl;

    }

    voidInfantry::attack()

    {

    cout << "Infantry--attack()"<< endl;

    cout <

    }

    main.cpp:

    #include

    #include"Infantry.h"

    #include

    using namespacestd;

    voidtest1(Person p)

    {

    p.play();

    }

    voidtest2(Person &p)

    {

    p.play();

    }

    voidtest3(Person *p)

    {

    p->play();

    }

    //无论继承的层级有多少,只要保持着直接或间接的继承关系,

    //子类都可以与自己的直接父类或间接父类称为is-a关系

    //并且能够通过指针对直接子类或间接子类的对象进行相应的操作

    intmain(void)

    {

    Infantry infantry;

    cout << endl;

    infantry.play();

    infantry.work();

    infantry.attack();

    cout << endl;

    test1(infantry);

    cout << endl;

    test2(infantry);

    cout << endl;

    test3(&infantry);

    system("pause");

    return0;

    }

    运行一览:

    7ab7c567a9b0f7d4371ae0be8f48e705.png

    程序 2:多继承

    Farmer.h:

    #include

    using namespacestd;

    classFarmer

    {

    public:

    Farmer(string name = "Jack");

    virtual~Farmer();//虚析构函数

    voidsow();

    protected:

    string m_strName;

    };

    Farmer.cpp:

    #include"Farmer.h"

    #include

    using namespacestd;

    Farmer::Farmer(string name)

    {

    m_strName = name;

    cout << "Farmer()"<< endl;

    }

    Farmer::~Farmer()

    {

    cout << "~Farmer()"<< endl;

    }

    voidFarmer::sow()

    {

    cout << "Farmer--sow()"<< endl;

    cout << m_strName << endl;

    }

    Worker.h:

    #include

    using namespacestd;

    classWorker

    {

    public:

    Worker(string code = "001");

    virtual~Worker();//虚析构函数

    voidwork();

    protected:

    string m_strCode;

    };

    Worker.cpp:

    #include"Worker.h"

    #include

    using namespacestd;

    Worker::Worker(string code)

    {

    m_strCode = code;

    cout << "Worker()"<< endl;

    }

    Worker::~Worker()

    {

    cout << "~Worker()"<< endl;

    }

    voidWorker::work()

    {

    cout << "Worker--work()"<< endl;

    cout << m_strCode << endl;

    }

    MigrantWorker.h:

    #include"Farmer.h"

    #include"Worker.h"

    classMigrantWorker :publicFarmer, publicWorker

    {

    public:

    MigrantWorker(string name, string code);

    virtual~MigrantWorker();

    };

    MigrantWorker.cpp:

    #include"MigrantWorker.h"

    #include

    using namespacestd;

    //使用初始化列表初始化

    MigrantWorker::MigrantWorker(string name, string code) :Farmer(name), Worker(code)

    {

    cout << "MigrantWorker()"<< endl;

    }

    MigrantWorker::~MigrantWorker()

    {

    cout << "~MigrantWorker()"<< endl;

    }

    main.cpp:

    #include

    #include"MigrantWorker.h"

    #include

    using namespacestd;

    intmain(void)

    {

    //从堆中实例化子类对象,先调用父类构造函数再调用子类构造函数

    //调用父类构造函数的顺序和初始化列表中的顺序一样

    //析构函数的调用顺序则相反

    MigrantWorker *p = newMigrantWorker("Merry", "100");

    cout << endl;

    p->sow();

    p->work();

    cout << endl;

    deletep;

    p = NULL;

    system("pause");

    return0;

    }

    运行一览:

    c59131ea477600ac370169c6e1b15420.png

    【made by siwuxie095】

    展开全文
  • 主要介绍了java为什么不允许类多重继承却允许接口多重继承,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • C++ 继承和多重继承

    2021-11-10 15:30:11
    多重继承是一个类的父类也父类,一层一层的继承父类。 多重继承的对象初始化方式最高的父类到子类。 A()–>B–>C() 销毁时正好是初始化的反顺序。 ~C–>~B–>A() class A{}; class B:public A{}; ...

    一、多重继承

    多重继承是一个类的父类也有父类,一层一层的继承父类。
    多重继承的对象初始化方式最高的父类到子类。
    A()–>B–>C()
    销毁时正好是初始化的反顺序。
    ~C–>~B–>A()

    class A{};
    class B:public A{};
    class C:public B{};

    用子类初始化父类,为避免内存泄露,父类的构析函数最好用virtual 修饰。

    二、多继承

    多继承:一个子类拥有很多父类 ,一般指一个类有2个以上父类。

    多继承的定义:派生类的基类大于一个。多
    多继承的对象初始化方式是父类依次初始化。
    A()–>B–>AB()
    销毁时正好是初始化的反顺序。
    ~AB–>~B()–>A~()

    class A{};
    class B{};
    class AB:public A,public B{};

    多继承语法:

    class  派生类名:继承方式1 基类名1,继承方式2 基类名2...

    {

    <派生类新定义成员>

    };

    多继承与构造函数的关系:

    多继承时构造函数的作用:

    1)初始化派生类(自己)

    2)调用该派生类的所有基类构造函数,并且为所有基类传参(参数个数必须包含所有基类所需参数)

    构造函数语法:

    派生类构造函数名(总参数表列): 基类1构造函数(参数表列), 基类2构造函数(参数表列), 基类3构造函数(参数表列)

    {

    //派生类中新增数成员据成员初始化语句

    }

    说明:派生类的构造函数的成员初始化列表中必须列出对虚基类构造函数的调用;如果未列出,则表示使用该虚基类的缺省构造函数。

    具体点来说:初始化列表中要包括对 直接基类 + 虚基类 进行调用。

    构造函数的执行次序(不含虚基类):

    (1)基类:依派生的次序决定,与构造函数中书写顺序无关

    (2)子对象的构造函数

    (3)派生类的构造函数

    析构函数的执行次序:和上述执行顺序相反

    注意:

    1)析构函数能继承;

    2)派生类中要定义自己的析构函数释放在派生中新增的成员;

    3)从基类中继承的成员释放,可以通过基类的析构函数实现;

    4)析构函数的调用顺序与构造函数调用顺序相反。

    #include <iostream>
    
    using namespace std;
    
    class A
    {
    public:
        A()
        {
            cout<<"调用A的构造函数"<<endl;
        }
    
    };
    
    
    class B
    {
    public:
        B()
        {
            cout<<"调用B的构造函数"<<endl;
        }
    
    };
    
    class C:public A,public B //这里声明顺序决定了调用基类的顺序
    {
    private:
        A a;
    public:
        C()
        {
            cout<<"调用C的构造函数"<<endl;
        }
    };
    
    void main()
    
    {
        C c;
        system("pause");
    }

    运行结果:

    调用A的构造函数--C的基类

    调用B的构造函数--C的基类

    调用A的构造函数--C的对象成员(C的成员变量)

    调用C的构造函数--C自己的构造函数

    三、虚继承

    虚拟继承是多重继承中特有的概念。虚拟基类是为解决多重继承而出现的。如:类D继承自类B1、B2,而类B1、B2都继承自类A,因此在类D中两次出现类A中的变量和函数,这时会产生二义性。为了解决二义性,同时为了节约内存,B1、B2对A的继承定义为虚拟继承,而A就成了虚拟基类,这样D中就只有一份A中的变量和函数。

    #include <iostream>
    using namespace std;
    class A
    {
    public:
    	A(int a)
    	{
    		m_a = a;
    		cout<<"调用A的构造函数"<<endl;
    		cout<<m_a<<endl;
    	}
    private:
    	int m_a;
    };
    
    class B
    {
    public:
    	B(int b)
    	{
    		m_b = b;
    		cout<<"调用B的构造函数"<<endl;
    		cout<<m_b<<endl;
    	}
    private:
    	int m_b;
    };
    
    
    class C
    {
    public:
    	C(int c)
    	{
    		m_c = c;
    		cout<<"调用C的构造函数"<<endl;
    		cout<<m_c<<endl;
    	}
    private:
    	int m_c;
    };
    
    class D:public A,public B, virtual public C //这里声明顺序决定了调用基类的顺序
    {
    public:
    	D(int a,int b,int c):A(a),B(b),C(c)
    	{
    		m_d = 4;
    		cout<<"调用D的构造函数"<<endl;
    		cout<<a<<" "<<b<<" "<<c<<" "<<m_d<<" "<<endl;
    	}
    private:
    	int m_d;
    
    };

    说明:

    1)C是D的虚基类,故先调用C的构造函数

    2)在同层次的多个虚基类中,从左到右调用,先B到C

    3)基类构造函数调用完后,在调用D的构造函数

    使用虚基类和不使用虚基类的说明:

    使用虚基类后的层次图:

    #include<iostream>
    using namespace std;
    class A
    {
    protected:
    	int a;
    public:
    	A(int a)
    	{
    		this->a=a;
    	}
    };
    class B:virtual public A
    {
    public:
    	B(int a):A(a)
    	 {
    	 }
    };
    class C:virtual public A
    {
    public:
    	C(int a):A(a)
    	{
    		this->a=a;
    	}
    };
    class D:public B,public C
    {
    public:
    	D(int a):B(a),C(a),A(a)//使用虚基类,声明时是 D的直接基类B和C + 直接基类的共同基类A
    	{
     
    	}
    	void display()
    	{
    		cout<<"a="<<a<<endl;
            //使用虚基类时,A只执行一次,调用B的时候调用一次虚基类,调用C时,就没有调用A了,D中的a也只有一个拷贝,因而不产生歧义
    	}
    };
    void main()
    {
    	D d(1);
    	d.display();
    	system("pause");
    }

     不使用虚基类后的层次图:

    虚继承就是为了节约内存的,他是多重继承中的特有的概念。适用与菱形继承形式。
    如:类B、C都继承类A,D继承类B和C。为了节省内存空间,可以将B、C对A的继承定义为虚拟继承,此时A就成了虚拟基类。
    class A;
    class B:vitual public A;
    class C:vitual public A;
    class D:public B,public C;
    虚函数继承就是覆盖。即基类中的虚函数被派生类中的同名函数所覆盖。
    class parent
    {
      public:
      vitual void foo(){cout < <"foo from parent";};
      void foo1(){cout < <"foo1 from parent";};
    };
    class son:public parent
    {
      void foo(){cout < <"foo from son";};
      void foo1(){cout < <"foo1 from son";};
    };
    int main()
    {
        parent *p=new son();
        p->foo();
        p->foo1();
        return 0;
    }
    其输出结果是:
    foo from son,foo1 from parent

    虚继承主要用于菱形形式的继承形式。

    1、真正意义上的虚函数调用,是运行时绑定的;
    2、什么是真正意义上的虚函数调用?通过指针或者引用执行虚函数;
    3、通过对象执行虚函数会不会是动态绑定的?不会。
    4、一个类是否有虚函数,就看它是否包含一个指向虚函数表的指针;
    5、如果类本身含有virtual 声明的函数,或者继承了virtual 函数,那么它肯定会包含一个指向虚函数表的指针;
    6、从纯抽象类或者非抽象类继承了virutal,意义上是一样的,效率上是一样的,并不因为你是纯抽象类的继承而效率变高;
    7、虚函数调用比普通函数调用慢多少?假设这个函数仅执行 return i  > j,大概慢 15%左右(3000万 * 100次规模测试),如果是个真正有意义上的函数,效率影响可以忽略不计;
    8、因此说虚函数慢的基本上是放屁,担心虚函数影响效率的基本上是杞人忧天;
    9、虚函数会慢,但是那是对内联函数而言的,虚函数会忽略 inline前缀,请注意这一点;
    10、继承层次不影响虚函数效率,如果你这个类是原始类的第10层继承,那么虚函数调用效率和第1层继承的类没有差别,当然如果你要在该函数中调用上一层的虚函数那就另当别论了;
    11、每个类应该只有一个virtual table,而不是每个对象有一个(对象只含有指向虚表的指针),那些说虚函数增大空间开销的可以自宫了;
    12、如果一个类含有虚函数,在构造时,使用memset(this, 0, sizeof(*this))是找死的行为;
    13、虚函数是运行时多态,模板是编译时多态,一个动,一个是静。

    14、子类覆盖父类的虚函数的时候,实际上是在构造函数中修改了虚表中的函数指针;因此使得 FatherClass* p = new ChildClass();的情况下,p->VirtualFunc()始终执行的是子类的虚函数;

    展开全文
  • 本文实例讲述了JavaScript实现多重继承的方法。分享给大家供大家参考,具体如下: 1. 定义一个空的父类构造函数,然后通过prototype的方式为该父类定义属性方法 2. 定义一个空的子类的构造函数,然后将子类的原型...
  • 同样的,在多重继承(multiple inheritance)关系中,派生类的对象包含了每个基类的子对象自定义成员的子对象。下面是一个多重继承关系图: class A{ /* */ }; class B{ /* */ }; class C : public A { /* */ };...
  • 继承:一个子类拥有很父类 多重继承 : 一层一层的继承父类 转载于:https://www.cnblogs.com/liunx1109/p/9439424.html

     

    多继承:一个子类拥有很多父类

    多重继承 : 一层一层的继承父类

     

    转载于:https://www.cnblogs.com/liunx1109/p/9439424.html

    展开全文
  • C++继承(多重继承)详解 在前面的例子中,派生类都只有一个基类,称为单继承(Single Inheritance)。除此之外,C++也支持继承(Multiple Inheritance),即一个派生类可以两个或个基类。 继承容易让代码...
  • 虽然super()函数的使用比较简单,但是需要根据单继承和多继承来分析函数的调用关系。 首先,当类之间的继承关系为单继承时,函数调用关系也比较简单,可以参考如下的例子: #!/usr/bin/env python3 class A(object)...
  • 多继承和多重代理在swift的语言层面上是不支持的,但我们有时会遇到这样的问题: 类BC分别继承自A,B1B2继承自B,C1C2继承自C.现在我们需要在B1C1中添加相同的方法,怎么去做?使用继承的话只能在类A中添加,但...
  • 主要介绍了C++多重继承态性原理实例详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • python多重继承实例

    2020-12-23 19:46:57
    本文实例讲述了python多重继承用法,分享给大家供大家参考。具体实现方法如下: 1.mro.py文件如下: #!/usr/bin/python # Filename:mro.py class P1: def foo(self): print 'called P1-foo' class P2: def foo...
  • JAVA中的多层继承

    2018-02-18 19:16:06
    类的继承格式、继承的关系表示图、访问限制、子类对象的实例化过程、方法的覆写、属性的覆盖、Super关键字、this与super的区别
  • 1. 多重继承即一个类继承了个基类的属性。 2. 多重继承下派生类的构造函数必须同时负责所有基类构造函数的调用, 3. 派生类构造函数的参数个数,必须满足个基类初始化的需要。 4. 在多重继承下,当建立派生类...
  • C++ 多重继承

    2021-01-20 13:39:42
    多重继承就是派生类继承个基类,继承方法一个继承是一样的。 一个继承请看我 —> “C++ 继承派生” 文章,会详细介绍。 链接: C++ 继承派生 在这里我主要讲多重继承的细节。 第一 继承方法: 例如已声明了...
  • 本文简单介绍多态和多重继承、虚拟继承的基本概念。随后重点分析了C++中对象模型之间的差异运行效率
  • 直接子类化内置类型(如dict,list或str)容易出错,因为内置类型的方法通常会忽略用户覆盖的方法,不要子类化内置类型,用户自定义的类应该继承collections模块。 def __setitem__(self, key, value): super().__...
  • 继承,多重继承,多层继承Inheritance is one of the most popular ways to reuse code in Angular. It has been used very frequently to build components. Yet, not many developers will apply inheritance to ...
  • 面试之后比较了 C++ Java 多态的实现的异同,一并记录在这里。 C++ 多态的虚指针实现 首先讨论 C++. 多态也即子类对父类成员函数进行了重写 (Override) 后,将一个子类指针赋值给父类,再对这个父类指针调用成员...
  • 在python中一个类能继承自不止一个父类,这叫做python的多重继承(Multiple Inheritance )。 语法 class SubclassName(BaseClass1, BaseClass2, BaseClass3, …): pass 菱形继承 在多层继承和多继承同时使用的...
  • pythonC++一样,支持多继承。概念虽然容易,但是困难的工作是如果子类调用一个自身没有定义的属性,它是按照何种顺序去到父类寻找呢,尤其是众多父类中有多个都包含该同名属性。 对经典类新式类来说,属性的查找...
  • 类的继承到多重继承详解以及如何使用super继承issubclass()的使用继承issubclass()多重继承和super()多重继承super() 继承issubclass()的使用 继承 继承就像是父与子的关系,子类可以从父类内里拿到相同的属性...
  • 正文 首先得说明的是,Python的类分为经典类 新式类 经典类是python2.2之前...2.经典类在类多重继承的时候是采用从左到右深度优先原则匹配方法的..而新式类是采用C3算法(不同于广度优先)进行匹配的 3.经典类是没有__
  • 多重继承是一个类的父类也父类。 多重继承的对象初始化方式最高的父类到子类。 A()–&gt;B–&gt;C() 销毁时正好是初始化的反顺序。 ~C–&gt;~B–&gt;A() 代码示例为: class A{}; class B...
  • C++继承和多重继承

    2020-02-07 12:09:48
    这篇为转载,担心原作删除看不了故转过来 ...多继承对父类的个数没有限制,继承方式可以是公共继承、保护继承和私有继承, 不写继承方式,默认是private继承 多继承举例: #include <iostream> #i...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 124,556
精华内容 49,822
关键字:

多继承和多重继承有什么区别

友情链接: CDMAfangzheng.rar