精华内容
下载资源
问答
  • 解释某个函数,我通常的讲解不会先去长篇大论去空谈,先整个例子来看看!!走起.... #include #include string> using namespace std; class A { public: A(const char*s) { coutendl; } }; class B:...
    • 解释某个函数,我通常的讲解不会先去长篇大论去空谈,先整个例子来看看!!走起....
    #include <iostream>
    #include <string>
    using namespace std;
    
    class A
    {
    public:
        A(const char*s)
        {
            cout<<s<<endl;
        }
    };
    class B:virtual public A
    {
    public:
        B(const char*s1,const char*s2):A(s1)
        {
            cout <<s2<<endl;
        }
    };
    
    class C:virtual public A
    {
    public:
        C(const char*s1,const char*s2):A(s1)
        {
            cout<<s2<<endl;
        }
    };
    
    class D:public B,C
    {
    public:
        D(const char *s1,const char *s2,const char*s3,const char*s4):B(s1,s2),C(s1,s3),A(s1)
        {
            cout <<s4<<endl;
        }
    };
    int main(int argc, char* argv[])
    {
        D *ptr = new D("class A","class B","class C","class D");
        delete ptr;
        ptr = NULL;
        return 0;
    }

    先不要忙着去执行代码!!

    来看几个基本概念:

    一、虚基类的作用:

    当一个类的部分或者全部基类来自另一个共同的基类时,这些直接基类中从上一级共同基类继承来的  就拥有相同的名称。在派生类的对象中,这些同名数据成员在内存中同时拥有多个拷贝,同一个函数名会有多个映射。我们可以使用作用域分蝙蝠来唯一标识并分别访问他们, 也可以将共同基类设置为虚基类,这时从不同的路径继承过来的同名数据成员在内存中就只用一个拷贝,同一个函数名也只有一个映射。

    二、虚基类的声明  语法形式:

    class 派生类名:virtual  继承方式  基类名

    三、使用虚基类时应该注意:

    1>一个类可以在一个类族中用作虚基类,也可以用作非虚基类。

    2>在派生类的对象中,同名的虚基类只产生一个虚基类子对象,而某个非虚基类产生各自的对象。

    3>虚基类子对象是由最派生类(最后派生出来的类)的构造函数通过调用虚基类的构造函数进行初始化。

    4>最派生类是指在继承类结构中建立对象时所指定的类。

    5>在派生类的构造函数的成员初始化列表中,必须列出对虚基类构造函数的调用,如果没有列出,则表示使用该虚基类的缺省构造函数。

    6>在虚基类直接或间接派生的派生类中的构造函数的成员初始化列表中,都要列出对虚基类构造函数的调用。但只有用于建立对象的最派生类的构造函数调用虚基类的构造函数,而该派生类的所有基类中列出的对虚基类构造函数的调用在执行中被忽略,从而保证对虚基类子对象只初始化一次。

    7>在一个成员初始化列表中,同时出现对虚基类和非虚基类构造函数的调用时,基类的构造函数先于非虚基类的构造函数执行。

    8>虚基类并不是在声明基类时声明的,而是在声明派生类是,指定继承方式时声明的。因为一个基类可以在生成一个派生类作为虚基类,而在生成另一个派生类时不作为虚基类。

    温馨提示:使用多重继承时要十分小心,经常会出现二义性。许多专业人员认为:不要提倡在程序中使用多重继承,只有在比较简单和不易出现二义性的情况或是在必要时才使用多重继承,能用单一继承解决的问题就不要使用多重继承,也是由于这个原因,有些面向对象的程序设计语言,并不支持多重继承。

    现在对虚基类构造函数了解了没??如果还不了解那么咱们就继续深入研究.....

    首先,要知道虚拟继承与普通继承的区别:

    假设derived继承自base类,那么derived与base是一种“is a”的关系,即derived类是base类,而反之错误;

    假设derived虚继承自base类,那么derived与base是一种“has a”的关系,即derived类有一个指向base类的vptr。

    因此虚继承可以认为不是一种继承关系,而可以认为是一种组合的关系。因为虚继承有着“继承”两个关键字,那么大部分人都认为虚继承与普通继承的用法没有什么太大的不同,由此用在继承体系中,这种将虚继承认为是普通继承的危害更加大!先用一个例子来说明问题:

    #include <iostream>
    using namespace std;
    
    class base
    {
    public:
        base()
        {
            cout <<"base::base()!"<<endl;
        }
        void printBase()
        {
            cout<<"base::printBase()!"<<endl;
        }
    };
    
    class derived:public base
    {
    public:
        derived()
        {
            cout<<"derived::derived()!"<<endl;
        }
        void printDerived()
        {
            cout<<"derived::printDerived()!"<<endl;
        }
    };
    
    int main(int argc, char* argv[])
    {
    
        derived oo;
        base oo1(static_cast<base>(oo));
    
        oo1.printBase();
    
        cout <<"---------------------"<<endl;
        derived oo2= static_cast<derived&>(oo1);
        oo2.printDerived();
    }

    运行结果:

    对前面的例子稍加修改......................

    #include <iostream>
    using namespace std;
    
    class base1
    {
    public:
        base1()
        {
            cout<<"base::base()!"<<endl;
        }
        void printBase()
        {
            cout<<"base::printBase()!"<<endl;
        }
    };
    class derived1:virtual public base1
    {
    public:
        derived1()
        {
            cout<<"derived::derived()!"<<endl;
        }
        void printDerived()
        {
            cout <<"derived::printDerived()!"<<endl ;
        }
    
    };
    
    int main(int argc, char* argv[])
    {
        derived1 oo;
        base1 oo1(static_cast<base1>(oo));
        oo1.printBase();
        
        derived1 oo2 = static_cast<derived1&>(oo1);
        oo2.printDerived();
        return 0;
    }

     

    会发现编译错误:error C2635: cannot convert a 'base1*' to a 'derived1*'; conversion from a virtual base class is implied(代码中红色部分出错)

    可以看到不能将基类通过static_cast转换为继承类。我们知道c++提供的强制转换函数static_cast对于继承体系中的类对象的转换一般是可行的。那么这里为什么不可以呢??

    virtual base class的原始模型是在class object中为每一个有关联的virtual base class加上一个指针vptr,该指针指向virtual基类表。有的编译器是在继承类已存在的virtual table直接扩充导入一个virtual base class table。不管怎么样由于虚继承已完全破坏了继承体系,不能按照平常的继承体系来进行类型转换。

     

    • 我们清楚了虚基类构造函数是怎么回事,那么接下来讲解一下 虚基类构造函数调用顺序 !!

    我们下来了解虚拟继承中遇到最广泛的菱形结构:

    #include <iostream>
    using namespace std;
    
    class stream
    {
    public:
        stream()
        {
            cout <<"stream::stream()!"<<endl;
        }
    };
    
    
    class iistream:virtual stream
    {
    public:
        iistream()
        {
            cout <<"istream::istream()!"<<endl;
        }
    };
    
    class oostream:virtual stream
    {
    public:
        oostream()
        {
            cout <<"ostream::ostream()!"<<endl;
        }
    };
    
    class iiostream:public iistream,oostream
    {
    public:
        iiostream()
        {
            cout<<"iiostream::iiostream()!"<<endl;
        }
    };
    
    int main(int argc, char* argv[])
    {
        iiostream oo;
        return 0;
    }

     

    运行结果:

    本来虚拟继承的目的就是当多重继承出现重复的基类时,其只保存一份基类,减少内存开销。

     

    这样子的菱形结构,使公共基类只产生一个拷贝。

    从基类stream派生新类时,使用virtual将类stream说明为虚基类,这时派生类istream、ostream包含一个指向虚基类的vptr,而不会产生实际的stream空间。所以最终iiostream也含有一个指向虚基类的vptr,调用stream中的成员方法时,通过vptr去调用,不会产生二义性!

    现在我们换种方式使用虚继承:

    #include <iostream>
    using namespace std;
    
    class stream
    {
    public:
        stream()
        {
            cout <<"stream::stream()!"<<endl;
        }
    };
    
    
    class iistream:public stream
    {
    public:
        iistream()
        {
            cout <<"istream::istream()!"<<endl;
        }
    };
    
    class oostream:public stream
    {
    public:
        oostream()
        {
            cout <<"ostream::ostream()!"<<endl;
        }
    };
    
    class iiostream:virtual iistream,oostream
    {
    public:
        iiostream()
        {
            cout<<"iiostream::iiostream()!"<<endl;
        }
    };
    
    int main(int argc, char* argv[])
    {
        iiostream oo;
        return 0;
    }

    运行结果:

    从结果上可以看到,其构造过程中重复出现基类的stream的构造过程,这样就完全没有达到虚拟继承的目的。其继承结构为:

    从继承结构可以看出,如果iiostream对象调用基类stream重的成员方法,会导致方法的二义性。因为iiostream含有指向其虚继承基类istream,ostream的vptr。而istream,ostream包含了stream的空间,所以导致iiostream不知道导致时调用那个stream的方法。要解决该问题,即在调用成员方法时需要加上作用域!

    转载自:http://blog.csdn.net/wzjking0929/article/details/51931204

    展开全文
  • 主要介绍了C#中派生类调用基类构造函数用法,实例分析了派生类调用基类构造函数的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • C++ 虚基类构造函数的执行顺序

    千次阅读 2014-03-04 09:20:13
    (1)调用基类的构造函数,多个基类则按派生类声明时  列出的次序、从左到右调用,而不是初始化列表中  的次序。 (2)调用对象成员(子对象)的构造...同一层中对虚基类构造函数的调用总是先于普通基类的构 造函数。

    (1)调用基类的构造函数,多个基类则按派生类声明时

              列出的次序、从左到右调用,而不是初始化列表中

              的次序。

    (2)调用对象成员(子对象)的构造函数,按类声明中

              对象成员出现的次序调用,而不是初始化列表中的

              次序。

    (3)执行派生类的构造函数。

    同一层中对虚基类构造函数的调用总是先于普通基类的构

    造函数。

    #include<iostream>
    using namespace std;
    
    class A//基类A
    {
    public:
    	A(){cout<<"class A"<<endl;}
    };
    
    class B: public A //由A类派生出类B
    {
    public:
    	B(){cout<<"class B"<<endl;}
    };
    
    class C1:virtual public B //由类B虚拟派生出类C1
    {
    public:
    	C1(){cout<<"class C1"<<endl;}
    };
    
    class C2:virtual public B //由类B虚拟派生出类C2
    {
    public:
    	C2(){cout<<"class C2"<<endl;}
    };
    
    class D:public C1, public C2 //由C1和C2派生出类D
    {
    public:
    	D(){cout<<"class D"<<endl;}
    };
    
    int main()
    {
    	D d;
    	return 0;
    }


    #include<iostream>
    using namespace std;
    
    class M
    {
    public:
    	M(const char *s){cout<<"M:"<<s<<endl;}
    };
    
    class A
    {
    	M m;
    public:
    	A(const char* s):m("in A"){cout<<"A:"<<s<<endl;}
    };
    
    class B
    {
    	M m;
    public:
    	B(const char* s):m("in B"){cout<<"B:"<<s<<endl;}
    };
    
    class C
    {
    	M m;
    public:
    	C(const char* s):m("in C"){cout<<"C:"<<s<<endl;}
    };
    
    class D
    {
    	M m;
    public:
    	D(const char* s):m("in D"){cout<<"D:"<<s<<endl;}
    };
    
    
    class E:public A, virtual public B, virtual public C
    {
    	M m;
    public:
    	E(const char* s):A("from E"),B("from E"),C("from E"),m("in E")
    	{cout<<"E:"<<s<<endl;}
    };
    
    class F:virtual public B, virtual public C, public D
    {
    	M m;
    public:
    	F(const char* s):B("from F"),C("from F"),D("from F"),m("in F")
    	{cout<<"F:"<<s<<endl;}
    };
    
    class G:public E, public F
    {
    	M m;
    public:
    	G(const char* s):B("from G"),C("from G"),E("from G"),F("from G"),m("in G")
    	{cout<<"G:"<<s<<endl;}
    };
    
    int main()
    {
    	G g("from main");
    	return 0;
    }
    



    展开全文
  • C++虚基类构造函数

    2016-06-14 16:12:06
    C++虚基类构造函数 下面文章详细介绍C++基,所谓C++基类:是由最派生类的构造函数通过调用基类的构造函数进行初始化的,但前提是要深入理解到底什么是C++基类,及他是怎么运行的。 前面讲过,为了初始化...

    C++虚基类构造函数
    下面文章详细介绍C++虚基,所谓C++虚基类:是由最派生类的构造函数通过调用虚基类的构造函数进行初始化的,但前提是要深入理解到底什么是C++虚基类,及他是怎么运行的。

    前面讲过,为了初始化基类的子对象,派生类的构造函数要调用基类的构造函数。对于虚基类来讲,由于派生类的对象中只有一个虚基类子对象。为保证虚基类子对象只被初始化一次,这个虚基类构造函数必须只被调用一次。

    由于继承结构的层次可能很深,规定将在建立对象时所指定的类称为最派生类。C++规定,虚基类子对象是由最派生类的构造函数通过调用虚基类的构造函数进行初始化的。如果一个派生类有一个直接或间接的C++虚基类,那么派生类的构造函数的成员初始列表中必须列出对虚基类构造函数的调用。如果未被列出,则表示使用该虚基类的缺省构造函数来初始化派生类对象中的虚基类子对象。

    从虚基类直接或间接继承的派生类中的构造函数的成员初始化列表中都要列出这个虚基类构造函数的调用。但是,只有用于建立对象的那个最派生类的构造函数调用虚基类的构造函数。

    而该派生类的基类中所列出的对这个虚基类的构造函数调用在执行中被忽略,这样便保证了对虚基类的对象只初始化一次。C++又规定,在一个成员初始化列表中出现对虚基类和非虚基类构造函数的调用,则C++虚基类的构造函数先于非虚基类的构造函数的执行。

    下面举一例子说明具有C++虚基类的派生类的构造函数的用法。

    class A  
    {  
    public:  
     A(const char *s) 
     { 
      cout<<s<<endl;// ~A() {}  
     }
    };   
    class B : virtual public A  
    {  
    public:  
     B(const char *s1, const char *s2):A(s1)  {  cout<<s2<<endl; }  
    };  

    class C : virtual public A  
    {  
    public:  C(const char *s1, const char *s2):A(s1)  {  cout<<s2<<endl; }  
    };  

    class D : public B, public C  
    {  
    public:  D(const char *s1, const char *s2, const char *s3, const char *s4) :B(s1, s2), C(s1, s3), A(s1)  
      {  
        cout<<s4<<endl; 
      }
    };  

    void main()  
    {  
     D *ptr = new D("class A", "class B", "class C", "class D");  
     delete ptr;  
     ptr = NULL;
    }
     
    打印结果:
    class A
    class B
    class C
    class D

    在派生类B和C中使用了C++虚基类,使得建立的D类对象只有一个虚基类子对象。在派生类B,C,D的构造函数的成员初始化列表中都包含了对虚基类A的构造函数。在建立类D对象时。

    只有C++虚基类D的构造函数的成员初始化列表中列出的虚基类构造函数被调用,并且仅调用一次,而类D基类的构造函数的成员初始化列表中列出的虚基类构造函数不被执行。这一点将从该程序的输出结果可以看出。

    展开全文
  • 我们将派生类直接基类的共同基类声明为虚基类后,派生类从不同的直接基类继承来的同名数据成员在内存中就会只有一份拷贝,同名函数也会只有一个映射,这样不仅实现了唯一标识同名成员,而且也节省了内存空间,可见...

    虚基类的概念及用法

    如果派生类的全部或者部分基类有共同的基类,那么派生类的这些直接基类从上一级基类继承的成员都具有相同的名称,定义了派生类的对象后,同名数据成员就会在内存中有多份拷贝,同名函数也会有多个映射。

    访问这些同名成员时,为了唯一标识它们可以使用上一讲中的作用域分辨符,也可以使用虚基类技术。

    我们将派生类直接基类的共同基类声明为虚基类后,派生类从不同的直接基类继承来的同名数据成员在内存中就会只有一份拷贝,同名函数也会只有一个映射,这样不仅实现了唯一标识同名成员,而且也节省了内存空间,可见虚基类技术是很实用的。

    在派生类声明时除继承方式外还使用关键字virtual限定基类的话,此基类就是虚基类。虚基类声明的语法形式为:

    class 派生类名:virtual 继承方式 基类名
    

    这里关键字virtual跟继承方式一样,只限定紧跟在它后面的基类。

    比如,声明了类A为虚基类,类B为A的派生类,类C也是A的派生类,类D是由类B和C共同继承而来,则类B和类C从A继承的同名数据成员在类D的对象中只有一份拷贝,同名函数成员也只有一个函数体。

    讲上一讲中的第二个例子做下修改,将Base0声明为虚基类来说明下虚基类的用法:我们先声明一个基类Base0,Base0中有数据成员x和函数成员show,再声明类Base1和Base2,它们都由Base0公有继承而来,与上一讲中不同的是派生时声明Base0为虚基类,最后从Base1和Base2共同派生出类Child。

    这时Base0的成员经过到Base1和Base2再到Child的两次派生过程,出现在Child类中时,数据成员x在内存中也只有一份拷贝,函数成员show也只有一个映射。

    #include <iostream>
    using namespace std;
    class Base0                  // 基类Base0的声明
    {
    public:
        int x;
        void show() { cout<<"x of Base0: "<<x<<endl; }
    };
    class Base1 : virtual public Base0    // Base0为虚基类,公有派生Base1类
    {
    };
    class Base2 : virtual public Base0    // Base0为虚基类,公有派生Base2类
    {
    };
    class Child : public Base1, public Base2
    {
    };
    int main()
    {
        Child child;
        child.x = 5;
        child.show();
        return 0;
    }
    

    在这里插入图片描述
    大家可以看到,声明虚基类只需要在它的派生类声明时使用关键字virtual修饰。

    我们对作用域分辨符和虚基类技术进行对比分析可知,使用作用域分辨符唯一标识同名成员时,派生类中有同名成员的多个拷贝,可以存放不同的数据,进行不同的操作,而使用虚基类时派生类的同名成员只有一份拷贝,更节省内存。

    我们在软件开发中可以根据实际情况自己做出选择。

    虚基类派生类的构造函数

    上面例子中各个类都没有定义构造函数,而是使用的默认构造函数。

    如果虚基类定义了带参数表的非默认构造函数,没有定义默认形式的构造函数,那么情况会有些复杂。因为由虚基类直接或间接继承的所有派生类,都必须在构造函数的成员初始化列表中给出对虚基类成员的初始化。

    这里再讲上面的例子做进一步修改,为虚基类添加带参数表的构造函数,那么整个程序就要改成以下形式:

    #include <iostream>
    using namespace std;
    class Base0                    // 基类Base0的声明
    {
    public:
        Base0(int y)     { x=y; }
        int x;
        void show()      { cout<<"x of Base0: "<<x<<endl; }
    };
    class Base1 : virtual public Base0     // Base0为虚基类,公有派生Base1类
    {
    public:
        Base1(int y):Base0(y)    { }
    };
    class Base2 : virtual public Base0     // Base0为虚基类,公有派生Base2类
    {
    public:
        Base2(int y):Base0(y)    { }
    };
    class Child : public Base1, public Base2
    {
    public:
        Child(int y):Base0(y),Base1(y),Base2(y)   { }
    };
    int main()
    {
        Child child(3);
        child.show();
        return 0;
    }
    

    在这里插入图片描述
    主函数中定义了派生类Child的对象child,在构造对象child时调用了child的构造函数,其初始化列表中不只调用了虚基类Base0的构造函数对从它继承的成员x进行初始化,而且还调用了基类Base1和Base2的构造函数Base1()和Base2(),而Base1()和Base2()的初始化列表中又有对虚基类Base0成员x的初始化。

    这么说,从虚基类Base0继承来的成员x初始化了三次,其实不然,因为编译器在遇到这种情况时会进行特殊处理:如果构造的对象中有从虚基类继承来的成员,那么虚基类成员的初始化由而且只由最远派生类的构造函数调用虚基类的构造函数来完成。

    最远派生类就是声明对象时指定的类,上面例子中构造对象child时,类Child就是最远派生类。

    除了最远派生类,它的其他基类对虚基类构造函数的调用会被忽略。

    上例中就只会由Child类的构造函数调用虚基类Base0的构造函数完成成员x的初始化,而Child类的基类Base1和Base2对虚基类Base0构造函数的调用会被忽略。

    展开全文
  • 下面文章详细介绍C++基,所谓C++基类:是由最派生类的构造函数通过调用基类的构造函数进行初始化的,但前提是要深入理解到底什么是C++基类,及...为保证基类子对象只被初始化一次,这个虚基类构造函数必须...
  • 虚基类构造函数

    千次阅读 2018-11-15 14:06:29
    基类的构造函数 #include &lt;iostream&gt; using namespace std; class base { private: int a ; public: base(int sa) ...基类构造函数"&lt;&lt; endl; } }; c...
  • //需要注意的是如果基类中没有默认构造函数,或者中间的派生类采用的不是默认构造函数或者有参数,那么在所有的派生类中必须都要有虚基类构造函数的说明 //而且只有最远派生类的对基类的构造函数使用有效,之前...
  • 虚基类 :  如果某个派生类的部分或全部直接基类是从另一个共同的基类派生而来,在这些基类中,从上一级基类继承来的成员就有相同的名称,则在这个派生类中访问这个共同的基类中的成员时,可能会产生二义性,此时,...
  • 《Visual C++2012入门经典(第6版)》实例,在派生类的构造函数中调用基类构造函数
  • #include<iostream> using namespace std; class Base//声明基类base { public: Base(int sa) ...class Base1:virtual public Base//声明类base是base1的虚基类 { public: Base1(int
  • c++ 派生类的构造函数 与 基类构造函数的关系

    千次阅读 多人点赞 2019-05-22 10:35:00
    《Thinking in C++》,刘宗田等译,第261页:可以看出,构造在类层次的最根处开始,而在每一层,首先调用基类构造函数,然后调用成员对象构造函数。 《C++ Primer Plus(第四版)中文版》,孙...
  • 基类构造函数调用函数时,不会调用派生类的函数。 现有基类A和派生类B,两个类中有成员函数 test()。程序刚进入B b时,在执行派生类B的构造函数时,需要首先调用基类A的构造函数。 那么调用的是哪个构造...
  • //析构函数做成员函数 }; Base::~Base()//成员函数实现 { cout; } class Derived:public Base { public: Derived(); ~Derived(); private: int *p; }; Derived::Derived() { p=new int(0);//从堆上分配一个int型...
  • 下面示例就是说明多重继承析构函数和构造函数的执行顺序: #include <iostream> using namespace std; class A { public: A(int i) { cout << "父类A构造函数被调用:" << i<<endl; } ...
  • 派生类调用基类构造函数

    千次阅读 2020-05-25 22:40:41
    不错的派生类调用基类构造函数 #include<iostream> using namespace std; class BASE{ public: /*****************found1*****************/ int i; BASE(int i){cout<<"调用基类BASE的构造函数:"<...
  •  《Thinking in C++》,刘宗田等译,第261页:可以看出,构造在类层次的最根处开始,而在每一层,首先调用基类构造函数,然后调用成员对象构造函数。  《C++ Primer Plus(第四版)中文版》,
  • 1、 当基类中没有自己编写构造函数时,派生类默认的调用基类的默认构造函数
  • C++子类继承基类构造函数问题

    多人点赞 2020-02-18 15:05:03
    先摘一段别人的: 构造方法用来初始化类的对象...如果没有显式的构造函数,编译器会给一个默认的构造函数,并且该默认的构造函数仅仅在没有显式地声明构造函数情况下创建。 构造原则如下: 1,如果子类没有定义构造...
  • 问题出来了,如果构造函数的,就需要通过 vtbl来调用,可是对象还没有实例化,也就是内存空间还没有,无法找到vtbl。所以构造函数不能是函数。 vtbl是在编译期就建立了,各个函数这时被组织成了一个函数...
  • 派生类构造函数的参数初始化列表,为什么不能初始化基类的成员? 例如下面的是不可以的 class Rectangle : public Shape { public: Rectangle () : id(1234), name("Rectangle") { // id: 父类Shape...
  • 1、虚基类的作用从上面的介绍可知:如果一个派生类有多个直接基类,而这些直接基类又有一个共同的基类,则在最终的派生类中会保留该间接共同基类数据成员的多份同名成员。 在引用这些同名的成员时,必须在派生类...
  • C++之基类构造函数初始化

    千次阅读 2018-09-19 13:44:36
    定义一个基类:初始化需要传入一个整数 class mybase { public: mybase(int iType); virtual ~mybase(); public: int m_iType; }; 在定义一个子类,继承于mybase class my:public mybase { public: my(); ...
  • C++ - 虚基类虚函数与纯虚函数

    千次阅读 多人点赞 2017-04-10 17:50:07
    转自:... 虚基类 在说明其作用前先看一段代码 classA { public: intiValue; }; classB:publicA { public: voidbPrintf(){cout<<"This is class B"<<...
  • 运行环境:macOS shell 代码:#include #include #include using namespace std;class base { protected: int x; public: base(int x1) { x = x1; cout<<"constr

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 186,238
精华内容 74,495
关键字:

虚基类构造函数