{"id":"58954461","type":"page","status":"current","title":"07.继承和派生","version":{"by":{"type":"known","username":"ethanliu","userKey":"2c90931b6cfb654f016d5c69becc0001","profilePicture":{"path":"/images/icons/profilepics/default.svg","width":48,"height":48,"isDefault":true},"displayName":"刘浩","_links":{"self":"https://wiki.suncaper.net/rest/api/user?key=2c90931b6cfb654f016d5c69becc0001"},"_expandable":{"status":""}},"when":"2022-07-09T01:51:24.000Z","message":"","number":1,"minorEdit":false,"hidden":false,"_links":{"self":"https://wiki.suncaper.net/rest/experimental/content/58954461/version/1"},"_expandable":{"content":"/rest/api/content/58954461"}},"body":{"storage":{"value":"<ac:layout><ac:layout-section ac:type=\"two_right_sidebar\"><ac:layout-cell><h2><span>4.7 </span>继承和派生</h2><h3><span>4.7.1 </span>继承概述</h3><h4><span>4.7.1.1 </span>为什么需要继承</h4><p><ac:image ac:height=\"400\"><ri:attachment ri:filename=\"image2021-5-13_10-35-7.png\" /></ac:image></p><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"163b7185-baac-44d8-9ad3-a9061d863bed\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[网页类\nclass IndexPage{\npublic:\n\t//网页头部\n\tvoid Header(){\n\t\tcout << \"网页头部!\" << endl;\n\t}\n\t//网页左侧菜单\n\tvoid LeftNavigation(){\n\t\tcout << \"左侧导航菜单!\" << endl;\n\t}\n\t//网页主体部分\n\tvoid MainBody(){\n\t\tcout << \"首页网页主题内容!\" << endl;\n\t}\n\t//网页底部\n\tvoid Footer(){\n\t\tcout << \"网页底部!\" << endl;\n\t}\nprivate:\n\tstring mTitle; //网页标题\n};\n\n#if 0\n//如果不使用继承，那么定义新闻页类，需要重新写一遍已经有的代码\nclass NewsPage{\npublic:\n\t//网页头部\n\tvoid Header(){\n\t\tcout << \"网页头部!\" << endl;\n\t}\n\t//网页左侧菜单\n\tvoid LeftNavigation(){\n\t\tcout << \"左侧导航菜单!\" << endl;\n\t}\n\t//网页主体部分\n\tvoid MainBody(){\n\t\tcout << \"新闻网页主体内容!\" << endl;\n\t}\n\t//网页底部\n\tvoid Footer(){\n\t\tcout << \"网页底部!\" << endl;\n\t}\nprivate:\n\tstring mTitle; //网页标题\n};\n\nvoid test(){\n\tNewsPage* newspage = new NewsPage;\n\tnewspage->Header();\n\tnewspage->MainBody();\n\tnewspage->LeftNavigation();\n\tnewspage->Footer();\n}\n#else\n//使用继承，可以复用已有的代码，新闻业除了主体部分不一样，其他都是一样的\nclass NewsPage : public IndexPage{\npublic:\n\t//网页主体部分\n\tvoid MainBody(){\n\t\tcout << \"新闻网页主主体内容!\" << endl;\n\t}\n};\nvoid test(){\n\tNewsPage* newspage = new NewsPage;\n\tnewspage->Header();\n\tnewspage->MainBody();\n\tnewspage->LeftNavigation();\n\tnewspage->Footer();\n}\n#endif\nint main(){\n\n\ttest();\n\n\treturn EXIT_SUCCESS;\n}]]></ac:plain-text-body></ac:structured-macro><h4><span>4.7.1.2 </span>继承基本概念</h4><p>c++最重要的特征是代码重用，通过继承机制可以利用已有的数据类型来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。</p><p>一个<span>B</span>类继承于<span>A</span>类，或称从类<span>A</span>派生类<span>B</span>。这样的话，类<span>A</span>成为基类（父类）， 类<span>B</span>成为派生类（子类）。</p><p>派生类中的成员，包含两大部分：</p><ul><li>一类是从基类继承过来的，一类是自己增加的成员。</li><li>从基类继承过过来的表现其共性，而新增的成员体现了其个性。</li></ul><h4><span>4.7.1.3 </span>派生类定义</h4><p><strong>派生类定义格式：</strong></p><table><tbody><tr><td><p><span>   Class </span>派生类名<span> :  </span>继承方式 基类名<span>{</span></p><p><span>         //</span>派生类新增的数据成员和成员函数</p><p><span>   }</span></p></td></tr></tbody></table><p><span> </span></p><p>三种继承方式：</p><ul><li>public ：<span> </span>公有继承</li><li>private ：<span> </span>私有继承</li><li>protected ： 保护继承</li></ul><p>从继承源上分：</p><ul><li>单继承：指每个派生类只直接继承了一个基类的特征</li><li>多继承：指多个基类派生出一个派生类的继承关系<span>,</span>多继承的派生类直接继承了不止一个基类的特征</li></ul><h3><span>4.7.2 </span>派生类访问控制</h3><p>派生类继承基类，派生类拥有基类中全部成员变量和成员方法（除了构造和析构之外的成员方法），但是在派生类中，继承的成员并不一定能直接访问，不同的继承方式会导致不同的访问权限。</p><p>派生类的访问权限规则如下：</p><p><ac:image ac:height=\"400\"><ri:attachment ri:filename=\"image2021-5-13_10-36-58.png\" /></ac:image></p><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"3e1b79ba-6cd5-4e38-9965-0dba517ceff3\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[//基类\nclass A{\npublic:\n\tint mA;\nprotected:\n\tint mB;\nprivate:\n\tint mC;\n};\n\n//1. 公有(public)继承\nclass B : public A{\npublic:\n\tvoid PrintB(){\n\t\tcout << mA << endl; //可访问基类public属性\n\t\tcout << mB << endl; //可访问基类protected属性\n\t\t//cout << mC << endl; //不可访问基类private属性\n\t}  \n};\nclass SubB : public B{\n\tvoid PrintSubB(){\n\t\tcout << mA << endl; //可访问基类public属性\n\t\tcout << mB << endl; //可访问基类protected属性\n\t\t//cout << mC << endl; //不可访问基类private属性\n\t}\n};\nvoid test01(){\n\n\tB b;\n\tcout << b.mA << endl; //可访问基类public属性\n\t//cout << b.mB << endl; //不可访问基类protected属性\n\t//cout << b.mC << endl; //不可访问基类private属性\n}\n\n//2. 私有(private)继承\nclass C : private A{\npublic:\n\tvoid PrintC(){\n\t\tcout << mA << endl; //可访问基类public属性\n\t\tcout << mB << endl; //可访问基类protected属性\n\t\t//cout << mC << endl; //不可访问基类private属性\n\t}\n};\nclass SubC : public C{\n\tvoid PrintSubC(){\n\t\t//cout << mA << endl; //不可访问基类public属性\n\t\t//cout << mB << endl; //不可访问基类protected属性\n\t\t//cout << mC << endl; //不可访问基类private属性\n\t}\n};\nvoid test02(){\n\tC c;\n\t//cout << c.mA << endl; //不可访问基类public属性\n\t//cout << c.mB << endl; //不可访问基类protected属性\n\t//cout << c.mC << endl; //不可访问基类private属性\n}\n//3. 保护(protected)继承\nclass D : protected A{\npublic:\n\tvoid PrintD(){\n\t\tcout << mA << endl; //可访问基类public属性\n\t\tcout << mB << endl; //可访问基类protected属性\n\t\t//cout << mC << endl; //不可访问基类private属性\n\t}\n};\nclass SubD : public D{\n\tvoid PrintD(){\n\t\tcout << mA << endl; //可访问基类public属性\n\t\tcout << mB << endl; //可访问基类protected属性\n\t\t//cout << mC << endl; //不可访问基类private属性\n\t}\n};\nvoid test03(){\n\tD d;\n\t//cout << d.mA << endl; //不可访问基类public属性\n\t//cout << d.mB << endl; //不可访问基类protected属性\n\t//cout << d.mC << endl; //不可访问基类private属性\n}]]></ac:plain-text-body></ac:structured-macro><h3><span>4.7.3 </span>继承中的构造和析构</h3><h4><span>4.7.3.1 </span>继承中的对象模型</h4><p>在<span>C++</span>编译器的内部可以理解为结构体，子类是由父类成员叠加子类新成员而成：</p><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"d6a08705-a98f-4bb6-b363-8a1f6e0784e1\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class Aclass{\npublic:\n\tint mA;\n\tint mB;\n};\nclass Bclass : public Aclass{\npublic:\n\tint mC;\n};\nclass Cclass : public Bclass{\npublic:\n\tint mD;\n};\nvoid test(){\n\tcout << \"A size:\" << sizeof(Aclass) << endl;\n\tcout << \"B size:\" << sizeof(Bclass) << endl;\n\tcout << \"C size:\" << sizeof(Cclass) << endl;\n}]]></ac:plain-text-body></ac:structured-macro><h4><span>4.7.3.2 </span>对象构造和析构的调用原则</h4><ul><li><strong>继承中的构造和析构</strong></li><li>子类对象在创建时会首先调用父类的构造函数</li><li>父类构造函数执行完毕后，才会调用子类的构造函数</li><li>当父类构造函数有参数时，需要在子类初始化列表<span>(</span>参数列表<span>)</span>中显示调用父类构造函数</li><li>析构函数调用顺序和构造函数相反</li></ul><p><ac:image ac:height=\"224\"><ri:attachment ri:filename=\"image2021-5-13_10-38-41.png\" /></ac:image></p><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"6b62b924-ea50-47fd-8fec-c093792b0262\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class A{\npublic:\n\tA(){\n\t\tcout << \"A类构造函数!\" << endl;\n\t}\n\t~A(){\n\t\tcout << \"A类析构函数!\" << endl;\n\t}\n};\n\nclass B : public A{\npublic:\n\tB(){\n\t\tcout << \"B类构造函数!\" << endl;\n\t}\n\t~B(){\n\t\tcout << \"B类析构函数!\" << endl;\n\t}\n};\n\nclass C : public B{\npublic:\n\tC(){\n\t\tcout << \"C类构造函数!\" << endl;\n\t}\n\t~C(){\n\t\tcout << \"C类析构函数!\" << endl;\n\t}\n};\n\nvoid test(){\n\tC c;\n}]]></ac:plain-text-body></ac:structured-macro><ul><li><strong>继承与组合混搭的构造和析构</strong></li></ul><p><strong><ac:image ac:height=\"173\"><ri:attachment ri:filename=\"image2021-5-13_10-39-35.png\" /></ac:image></strong></p><p><br /></p><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"98df7d16-7f94-4403-b3f6-d9542ee0f0fc\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class D{\npublic:\n\tD(){\n\t\tcout << \"D类构造函数!\" << endl;\n\t}\n\t~D(){\n\t\tcout << \"D类析构函数!\" << endl;\n\t}\n};\nclass A{\npublic:\n\tA(){\n\t\tcout << \"A类构造函数!\" << endl;\n\t}\n\t~A(){\n\t\tcout << \"A类析构函数!\" << endl;\n\t}\n};\nclass B : public A{\npublic:\n\tB(){\n\t\tcout << \"B类构造函数!\" << endl;\n\t}\n\t~B(){\n\t\tcout << \"B类析构函数!\" << endl;\n\t}\n};\nclass C : public B{\npublic:\n\tC(){\n\t\tcout << \"C类构造函数!\" << endl;\n\t}\n\t~C(){\n\t\tcout << \"C类析构函数!\" << endl;\n\t}\npublic:\n\tD c;\n};\nvoid test(){\n\tC c;\n}]]></ac:plain-text-body></ac:structured-macro><h3><span>4.7.3 </span>继承中同名成员的处理方法</h3><ul><li>当子类成员和父类成员同名时，子类依然从父类继承同名成员</li><li>如果子类有成员和父类同名，子类访问其成员默认访问子类的成员<span>(</span>本作用域，就近原则<span>)</span></li><li>在子类通过作用域<span>::</span>进行同名成员区分<span>(</span>在派生类中使用基类的同名成员，显示使用类名限定符<span>)</span></li></ul><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"c62080d7-c4ae-4ca5-8ac7-257680a04562\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class Base{\npublic:\n\tBase():mParam(0){}\n\tvoid Print(){ cout << mParam << endl; }\npublic:\n\tint mParam;\n};\n\nclass Derived : public Base{\npublic:\n\tDerived():mParam(10){}\n\tvoid Print(){\n\t\t//在派生类中使用和基类的同名成员,显示使用类名限定符\n\t\tcout << Base::mParam << endl;\n\t\tcout << mParam << endl;\n\t}\n\t//返回基类重名成员\n\tint& getBaseParam(){ return  Base::mParam; }\npublic:\n\tint mParam;\n};\n\nint main(){\n\n\tDerived derived;\n\t//派生类和基类成员属性重名，子类访问成员默认是子类成员\n\tcout << derived.mParam << endl; //10\n\tderived.Print();\n\t//类外如何获得基类重名成员属性\n\tderived.getBaseParam() = 100;\n\tcout << \"Base:mParam:\" << derived.getBaseParam() << endl;\n\n\treturn EXIT_SUCCESS;\n}]]></ac:plain-text-body></ac:structured-macro><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"cebfd30d-26e7-466d-b72b-01b92e8878fc\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class Base{\npublic:\n\tvoid func1(){\n\t\tcout << \"Base::void func1()\" << endl;\n\t};\n\tvoid func1(int param){\n\t\tcout << \"Base::void func1(int param)\" << endl;\n\t}\n\tvoid myfunc(){\n\t\tcout << \"Base::void myfunc()\" << endl;\n\t}\n};\nclass Derived1 : public Base{\npublic:\n\tvoid myfunc(){\n\t\tcout << \"Derived1::void myfunc()\" << endl;\n\t}\n};\nclass Derived2 : public Base{\npublic:\n\t//改变成员函数的参数列表\n\tvoid func1(int param1, int param2){\n\t\tcout << \"Derived2::void func1(int param1,int param2)\" << endl;\n\t};\n};\nclass Derived3 : public Base{\npublic:\n\t//改变成员函数的返回值\n\tint func1(int param){\n\t\tcout << \"Derived3::int func1(int param)\" << endl;\n\t\treturn 0;\n\t}\n};\nint main(){\n\n\tDerived1 derived1;\n\tderived1.func1();\n\tderived1.func1(20);\n\tderived1.myfunc();\n\tcout << \"-------------\" << endl;\n\tDerived2 derived2;\n\t//derived2.func1();  //func1被隐藏\n\t//derived2.func1(20); //func2被隐藏\n\tderived2.func1(10,20); //重载func1之后，基类的函数被隐藏\n\tderived2.myfunc();\n\tcout << \"-------------\" << endl;\n\tDerived3 derived3;\n\t//derived3.func1();  没有重新定义的重载版本被隐藏\n\tderived3.func1(20);\n\tderived3.myfunc();\n\n\treturn EXIT_SUCCESS;\n}]]></ac:plain-text-body></ac:structured-macro><ul><li>Derive1 重定义了<span>Base</span>类的<span>myfunc</span>函数，<span>derive1</span>可访问<span>func1</span>及其重载版本的函数。</li><li>Derive2通过改变函数参数列表的方式重新定义了基类的<span>func1</span>函数，则从基类中继承来的其他重载版本被隐藏，不可访问</li><li>Derive3通过改变函数返回类型的方式重新定义了基类的<span>func1</span>函数，则从基类继承来的没有重新定义的重载版本的函数将被隐藏。</li></ul><table><colgroup><col /></colgroup><tbody><tr><td><p>任何时候重新定义基类中的一个重载函数，在新类中所有的其他版本将被自动隐藏<span>.</span></p></td></tr></tbody></table><h3><span>4.7.4 </span>非自动继承的函数</h3><p>不是所有的函数都能自动从基类继承到派生类中。构造函数和析构函数用来处理对象的创建和析构操作，构造和析构函数只知道对它们的特定层次的对象做什么，也就是说构造函数和析构函数不能被继承，必须为每一个特定的派生类分别创建。</p><p>另外<span>operator=</span>也不能被继承，因为它完成类似构造函数的行为。也就是说尽管我们知道如何由<span>=</span>右边的对象如何初始化<span>=</span>左边的对象的所有成员，但是这个并不意味着对其派生类依然有效。</p><p>在继承的过程中，如果没有创建这些函数，编译器会自动生成它们。</p><h3><span>4.7.5 </span>继承中的静态成员特性</h3><p>静态成员函数和非静态成员函数的共同点<span>:</span></p><ol><li>他们都可以被继承到派生类中。</li><li>如果重新定义一个静态成员函数，所有在基类中的其他重载函数会被隐藏。</li><li>如果我们改变基类中一个函数的特征，所有使用该函数名的基类版本都会被隐藏。</li></ol><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"47a08a77-c744-4c18-8d27-37f5ad5e49d6\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class Base{\npublic:\n\tstatic int getNum(){ return sNum; }\n\tstatic int getNum(int param){\n\t\treturn sNum + param;\n\t}\npublic:\n\tstatic int sNum;\n};\nint Base::sNum = 10;\n\nclass Derived : public Base{\npublic:\n\tstatic int sNum; //基类静态成员属性将被隐藏\n#if 0\n\t//重定义一个函数，基类中重载的函数被隐藏\n\tstatic int getNum(int param1, int param2){\n\t\treturn sNum + param1 + param2;\n\t}\n#else\n\t//改变基类函数的某个特征，返回值或者参数个数，将会隐藏基类重载的函数\n\tstatic void getNum(int param1, int param2){\n\t\tcout <<  sNum + param1 + param2 << endl;\n\t}\n#endif\n};\nint Derived::sNum = 20;]]></ac:plain-text-body></ac:structured-macro><h3><span>4.7.6 </span>多继承</h3><h4><span>4.7.6.1 </span>多继承概念</h4><p>我们可以从一个类继承，我们也可以能同时从多个类继承，这就是多继承。但是由于多继承是非常受争议的，从多个类继承可能会导致函数、变量等同名导致较多的歧义。</p><p><ac:image ac:height=\"237\"><ri:attachment ri:filename=\"image2021-5-13_10-46-48.png\" /></ac:image></p><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"d3e89535-a805-46d3-8919-44fe450ab18e\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class Base1{\npublic:\n\tvoid func1(){ cout << \"Base1::func1\" << endl; }\n};\nclass Base2{\npublic:\n\tvoid func1(){ cout << \"Base2::func1\" << endl; }\n\tvoid func2(){ cout << \"Base2::func2\" << endl; }\n};\n//派生类继承Base1、Base2\nclass Derived : public Base1, public Base2{};\nint main(){\n\n\tDerived derived;\n\t//func1是从Base1继承来的还是从Base2继承来的？\n\t//derived.func1(); \n\tderived.func2();\n\n\t//解决歧义:显示指定调用那个基类的func1\n\tderived.Base1::func1(); \n\tderived.Base2::func1();\n\n\treturn EXIT_SUCCESS;\n}]]></ac:plain-text-body></ac:structured-macro><p>多继承会带来一些二义性的问题， 如果两个基类中有同名的函数或者变量，那么通过派生类对象去访问这个函数或变量时就不能明确到底调用从基类<span>1</span>继承的版本还是从基类<span>2</span>继承的版本？</p><p>解决方法就是显示指定调用那个基类的版本。</p><h4><span>4.7.6.2 </span>菱形继承和虚继承</h4><p>两个派生类继承同一个基类而又有某个类同时继承者两个派生类，这种继承被称为菱形继承，或者钻石型继承。</p><p><span> <ac:image ac:height=\"400\"><ri:attachment ri:filename=\"image2021-5-13_10-48-36.png\" /></ac:image></span></p><p>这种继承所带来的问题：</p><ol><li>羊继承了动物的数据和函数，鸵同样继承了动物的数据和函数，当草泥马调用函数或者数据时，就会产生二义性。</li><li>草泥马继承自动物的函数和数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。</li></ol><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"5a226508-b9c4-426a-8aef-a14f1b4e0b62\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class BigBase{\npublic:\n\tBigBase(){ mParam = 0; }\n\tvoid func(){ cout << \"BigBase::func\" << endl; }\npublic:\n\tint mParam;\n};\n\nclass Base1 : public BigBase{};\nclass Base2 : public BigBase{};\nclass Derived : public Base1, public Base2{};\n\nint main(){\n\n\tDerived derived;\n\t//1. 对“func”的访问不明确\n\t//derived.func();\n\t//cout << derived.mParam << endl;\n\tcout << \"derived.Base1::mParam:\" << derived.Base1::mParam << endl;\n\tcout << \"derived.Base2::mParam:\" << derived.Base2::mParam << endl;\n\n\t//2. 重复继承\n\tcout << \"Derived size:\" << sizeof(Derived) << endl; //8\n\n\treturn EXIT_SUCCESS;\n}]]></ac:plain-text-body></ac:structured-macro><p>上述问题如何解决？对于调用二义性，那么可通过指定调用那个基类的方式来解决，那么重复继承怎么解决？</p><p>对于这种菱形继承所带来的两个问题，<span>c++</span>为我们提供了一种方式，采用虚基类。那么我们采用虚基类方式将代码修改如下：</p><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"d4f7ad90-68ad-46d8-a1f2-705a3447e880\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class BigBase{\npublic:\n\tBigBase(){ mParam = 0; }\n\tvoid func(){ cout << \"BigBase::func\" << endl; }\npublic:\n\tint mParam;\n};\n\nclass Base1 : virtual public BigBase{};\nclass Base2 : virtual public BigBase{};\nclass Derived : public Base1, public Base2{};\n\nint main(){\n\n\tDerived derived;\n\t//二义性问题解决\n\tderived.func();\n\tcout << derived.mParam << endl;\n\t//输出结果:12\n\tcout << \"Derived size:\" << sizeof(Derived) << endl;\n\n\treturn EXIT_SUCCESS;\n}]]></ac:plain-text-body></ac:structured-macro><p>以上程序Base1 ，<span>Base2</span>采用虚继承方式继承<span>BigBase,</span>那么<span>BigBase</span>被称为虚基类。</p><p>通过虚继承解决了菱形继承所带来的二义性问题。</p><p><strong>但是虚基类是如何解决二义性的呢？并且<span>derived</span>大小为<span>12</span>字节，这是怎么回事？</strong></p><h4><span>4.7.6.3 </span>虚继承实现原理</h4><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"68eef820-340a-4110-9bcd-65a9f1f5c977\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class BigBase{\npublic:\n\tBigBase(){ mParam = 0; }\n\tvoid func(){ cout << \"BigBase::func\" << endl; }\npublic: int mParam;\n};\n#if 0 //虚继承\nclass Base1 : virtual public BigBase{};\nclass Base2 : virtual public BigBase{};\n#else //普通继承\nclass Base1 :  public BigBase{};\nclass Base2 :  public BigBase{};\n#endif\nclass Derived : public Base1, public Base2{};]]></ac:plain-text-body></ac:structured-macro><p><br /></p><p>通过内存图，我们发现普通继承和虚继承的对象内存图是不一样的。我们也可以猜测到编译器肯定对我们编写的程序做了一些手脚。</p><p><br /></p><ul><li>BigBase 菱形最顶层的类，内存布局图没有发生改变。</li><li>Base1和<span>Base2</span>通过虚继承的方式派生自<span>BigBase,</span>这两个对象的布局图中可以看出编译器为我们的对象中增加了一个<span>vbptr (virtual base pointer),vbptr</span>指向了一张表，这张表保存了当前的虚指针相对于虚基类的首地址的偏移量。</li><li>Derived派生于<span>Base1</span>和<span>Base2,</span>继承了两个基类的<span>vbptr</span>指针，并调整了<span>vbptr</span>与虚基类的首地址的偏移量。</li></ul><p><span> </span></p><p>由此可知编译器帮我们做了一些幕后工作，使得这种菱形问题在继承时候能只继承一份数据，并且也解决了二义性的问题。现在模型就变成了<span>Base1</span>和<span> Base2 Derived</span>三个类对象共享了一份<span>BigBase</span>数据。</p><p><br /></p><p>当使用虚继承时，虚基类是被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中均只会出现一个虚基类的子对象（这和多继承是完全不同的）。即使共享虚基类，但是必须要有一个类来完成基类的初始化（因为所有的对象都必须被初始化，哪怕是默认的），同时还不能够重复进行初始化，那到底谁应该负责完成初始化呢？C++标准中选择在<strong>每一次继承子类</strong>中都必须书写初始化语句（因为每一次继承子类可能都会用来定义对象），但是虚基类的初始化是由最后的子类完成，其他的初始化语句都不会调用。</p><ac:structured-macro ac:name=\"code\" ac:schema-version=\"1\" ac:macro-id=\"ee950f16-94da-454b-878a-748a6e288c17\"><ac:parameter ac:name=\"language\">cpp</ac:parameter><ac:plain-text-body><![CDATA[class BigBase{\npublic:\n\tBigBase(int x){mParam = x;}\n\tvoid func(){cout << \"BigBase::func\" << endl;}\npublic:\n\tint mParam;\n};\nclass Base1 : virtual public BigBase{\npublic:\n\tBase1() :BigBase(10){} //不调用BigBase构造\n};\nclass Base2 : virtual public BigBase{\npublic:\n\tBase2() :BigBase(10){} //不调用BigBase构造\n};\n\nclass Derived : public Base1, public Base2{\npublic:\n\tDerived() :BigBase(10){} //调用BigBase构造\n};\n//每一次继承子类中都必须书写初始化语句\nint main(){\n\tDerived derived;\n\treturn EXIT_SUCCESS;\n}]]></ac:plain-text-body></ac:structured-macro><p><strong>注意：</strong></p><table><tbody><tr><td><p>    虚继承只能解决具备公共祖先的多继承所带来的二义性问题，不能解决没有公共祖先的多继承的<span>.</span></p></td></tr></tbody></table><p><span> </span>工程开发中真正意义上的多继承是几乎不被使用，因为多重继承带来的代码复杂性远多于其带来的便利，多重继承对代码维护性上的影响是灾难性的，在设计方法上，任何多继承都可以用单继承代替。</p><p><br /></p></ac:layout-cell><ac:layout-cell><p><br /></p></ac:layout-cell></ac:layout-section></ac:layout>","representation":"storage","_expandable":{"content":"/rest/api/content/58954461"}},"_expandable":{"editor":"","view":"","export_view":"","styled_view":"","anonymous_export_view":""}},"extensions":{"position":"none"},"_links":{"webui":"/pages/viewpage.action?pageId=58954461","edit":"/pages/resumedraft.action?draftId=58954461","tinyui":"/x/3ZKDAw","collection":"/rest/api/content","base":"https://wiki.suncaper.net","context":"","self":"https://wiki.suncaper.net/rest/api/content/58954461"},"_expandable":{"container":"/rest/api/space/2CT","metadata":"","operations":"","children":"/rest/api/content/58954461/child","restrictions":"/rest/api/content/58954461/restriction/byOperation","history":"/rest/api/content/58954461/history","ancestors":"","descendants":"/rest/api/content/58954461/descendant","space":"/rest/api/space/2CT"}}