精华内容
下载资源
问答
  • (2):如果尤其它基类,则按照他们在继承声明列表中的出现次序,分别执行他们的构造函数,但构造过程中,不再执行虚基类的构造函数。 #include using namespace std; class base0{ public: base0(int var):var0...

    构造一个类的对象的一般顺序是:

    (1):如果有直接或间接的虚基类,先执行虚基类的构造函数

    (2):如果尤其它基类,则按照他们在继承声明列表中的出现次序,分别执行他们的构造函数,但构造过程中,不再执行虚基类的构造函数。

    #include<iostream>
    using namespace std;
    class base0{
    	public:
    	base0(int var):var0(var){cout<<"ggggg"<<endl;};
    	int var0;
    	void fun0(){cout<<"memory of base0"<<endl;}
    	~base0(){cout<<"gggg"<<endl;}
    };
    class base1:virtual public base0{
    public:
      base1(int var):base0(var){cout<<"hhhhh"<<endl;}
      int var1;
      ~base1(){cout<<"HHHH"<<endl;}
    };
    class base2:virtual public base0{
    public:
      base2(int var):base0(var){cout<<"tttttt"<<endl;}
      int var2;
    };
    class mm:public base1,public base2{
    	public:
    	 mm(int var):base1(var),base0(var),base2(var){cout<<"ppppp"<<endl;}
    	 int var;
    	 void fun(){cout<<"member of mm"<<endl;}
    	 ~mm(){cout<<"ppppp"<<endl;}
    };
    int main(){
    	mm a(1);
    	a.var=2;
    	a.fun();
    	return 0;
    }
    


    展开全文
  • 构造函数的执行顺序,派生构造函数 and 父类构造函数 and 成员对象构造函数

    对于派生类的构造函数,定义对象时构造函数的执行顺序为 2->1->3

    1、成员对象构造函数

    2、基类构造函数

    3、派生类本身构造函数

    #include <iostream>
    using namespace std;
    
    class A
    {
    public:
    	A()
    	{
    		cout<<"The constructor of A"<<endl;
    	}
    };
    class C
    {
    public:
    	C()
    	{
    		cout<<"The constructor of C"<<endl;
    	}
    };
    class B:public A
    {
    	C member_c;
    public:
    	B()
    	{
    		cout<<"The constructor of B"<<endl;
    	}
    };
    
    int main(void)
    {
    	B member_b;
    
    	system("pause");
    	return 0;
    }

    展开全文
  • C++派生构造函数

    2018-06-21 19:44:51
    如果对基类初始化时,需要调用基类的带有形参表的构造函数时,派生类就必须声明构造函数,提供一个将参数传递给基类构造函数的途径,保证在基类进行初始化时能够获得必要的数据。 派生构造函数执行的一般次序...

    如果对基类初始化时,需要调用基类的带有形参表的构造函数时,派生类就必须声明构造函数,提供一个将参数传递给基类构造函数的途径,保证在基类进行初始化时能够获得必要的数据。

    派生类构造函数执行的一般次序如下:

    1、调用基类构造函数,调用顺序按照它们被继承时声明的顺序(从左向右)。
    2、对派生类新增的成员对象初始化,调用顺序按照它们在类中声明的顺序。
    3、执行派生类的构造函数体中的内容。

    实例分析:

    #include <iostream>
    using namespace std;
    class Base1{
        public : Base1(int i){cout<<"构造 Base1 "<<i<<endl; }
    }; 
    class Base2{
        public : Base2(int j){cout<<"构造 Base2 "<<j<<endl;}
    
    }; 
    class Base3{
        public: Base3(){cout<<"构造 Base3 *"<<endl;}
    };
    
    
    class Deriverd: public Base2,public Base1,public Base3{
        public :
            Deriverd(int a,int b,int c,int d):Base1(a),member2(d),member1(c),Base2(b)
            {} 
        private:
            Base1 member1;
            Base2 member2;
            Base3 member3;
    };
    
    int main (){
        Deriverd obj(1,2,3,4);
        return 0;
    }

    该程序执行情况如下 :
    这里写图片描述

    派生类的构造函数定义如下:
    Deriverd(int a,int b,int c,int d):Base1(a),member2(d),member(c),Base2(b) {}
    这里有两个问题需要注意:首先这里并没有列出全部的基类和成员函数,由于Base3只有默认构造函数,不需要给他传递参数,因此,基类Base3以及Base3的成员对象member3就不必列出。其次,基类名和成员对象名的顺序是随意的。
    程序的主函数声明了一个派生类Deriverd的对象obj,生成对象obj时调用了派生类的构造函数。此构造函数的执行情况是先调用基类的构造函数,然后调用内嵌对象的构造函数。基类构造函数按照派生类定义时的顺序,因此应该是Base2,Base1,Base3。而内嵌对象的的构造函数调用顺序是按照成员在类中声明的顺序,应该是Base1,Base2,Base3.
    此时Base1的对象member1传递的参数是c,Base2的对象member2传递的参数是d。

    总结:

    c++中的类是数据和动作的集合,该派生类继承了三个基类,又调用了基类的三个对象,所以该类能够 “执行6个动作” 。派生类的构造函数需要以合适的初值作为参数,其中一些传递给基类的构造函数,用于初始化相应成员,另一些参数要用于对派生类新增的成员对象进行初始化。

    展开全文
  • 派生构造函数规则

    千次阅读 2015-01-19 16:21:12
    如果基类拥有构造函数但是没有默认构造函数,那么派生类的构造函数必须显示的调用基类的某个构造函数。   以B类从A类派生为例,我们总结如下: 1、若B有构造函数而A没有,当创建B类的对象时,B的相应构造函数被自动...

                                   派生类构造函数规则

    如果基类拥有构造函数但是没有默认构造函数,那么派生类的构造函数必须显示的调用基类的某个构造函数。

     

    B类从A类派生为例,我们总结如下:

    1、若B有构造函数而A没有,当创建B类的对象时,B的相应构造函数被自动调用。

    2、若B没有构造函数而A有,则A必须拥有默认构造函数,只有这样,当创建B类的对象时,才能自动执行A的默认构造函数。

    3、若B有构造函数,且A有默认构造函数,则创建B类的对象时,A的默认构造函数会自动执行,除非当前被调用的派生类构造函数在其初始化段中显示的调用了A的非默认构造函数。

    4、若BA都有构造函数,但A没有默认构造函数,则B的每个构造函数必须在其初始化段中显示地调用A的某个构造函数。只有这样,当创建B的对象时,A的构造函数才能获得执行机会。

    再次强调,在创建派生类对象时,必须显示地或隐式地执行其基类的某个构造函数,这一点非常重要,有时候,派生类的构造函数可能会依赖基类的构造函数来完成一些必要的操作,例如,依赖基类的构造函数来完成部分数据成员的初始化。而且,一般可以认为派生类对象是对基类对象的特化,这进一步说明了为什么基类的构造函数(如果该类有构造函数)必须在派生类对象创建时首先执行,在此之后,派生类的构造函数再负责处理派生类中的特化信息(派生类中的新增数据成员)。

    代码实例:(1

    <span style="font-size:14px;">#include <iostream> 
    using namespace std;  
    class A  
    {  
    public:
    private:  
        int x;  
    }; 
    class B:public A  
    {  
    public:  
        B(int c)  
        {  
            y=c;  
            cout<<"Bb"<<endl;  
        }  
        void fun()  
        {  
            cout<<"in B fun"<<endl;  
        }  
    private:  
        int y;  
    };  
    int main(void)  
    {  
        
        A *b=new B(2); 
        system("pause");  
        return 0;  
    }</span>


    执行结果为Bb

     

    代码实例(2

    #include <iostream>  
    using namespace std;  
    class A  
    {  
    public:  
        A() {cout<<"Aa"<<endl; }     
    private:  
        int x;  
    };  
    class B:public A  
    {  
    public:  
       
    private:  
        int y;  
    };  
    int main(void)  
    {  
        
        A*b=new B;
        system("pause");  
        return 0;  
    } 


    执行结果为Aa

     

    代码实例(3):

    <span style="font-size:14px;">#include <iostream>  
    using namespace std;  
    class A  
    {  
    public:  
        A() {cout<<"Aa"<<endl; }    
        A(int c)  
        {  
            x=c;  
            cout<<"A"<<endl;  
        }  
        void fun()  
        {  
            cout<<"in A fun"<<endl;  
        }  
    private:  
        int x;  
    };    
    class B:public A  
    {  
    public:  
        /*
    B(int c,int b) :A(c) 
        {  
            y=b;  
            cout<<"B"<<endl;  
        }  
    */
    B(int c)  
        {  
            y=c;  
            cout<<"Bb"<<endl;  
        }  
        void fun()  
        {  
            cout<<"in B fun"<<endl;  
        }  
    private:  
        int y;  
    };  
    int main(void)  
    {  
        //A *a=new B(2,3); 
        A *b=new B(2); 
        // A*b=new B;
        system("pause");  
        return 0;  
    }</span>


    执行结果是Aa Bb

     

    代码实例(4

    <span style="font-size:14px;">#include <iostream> 
    using namespace std;  
    class A  
    {  
    public:  
        //A() {cout<<"Aa"<<endl; }    
        A(int c)  
        {  
            x=c;  
            cout<<"A"<<endl;  
        }  
    private:  
        int x;  
    };  
    class B:public A  
    {  
    public:  
        
    B(int c,int b) :A(c) 
        {  
            y=b;  
            cout<<"B"<<endl;  
        }  
    /*
    B(int c)  
        {  
            y=c;  
            cout<<"Bb"<<endl;  
        }  */
    private:  
        int y;  
    };  
    int main(void)  
    {  
        A *a=new B(2,3); 
        //A *b=new B(2); 
        // A*b=new B;
        system("pause");  
        return 0;  
    }</span>


    执行结果A B

     

    代码实例(5

    <span style="font-size:14px;">#include <iostream>  
    using namespace std;  
    class A  
    {  
    public:  
        A() {cout<<"Aa"<<endl; }   
        A(int c)  
        {  
            x=c;  
            cout<<"A"<<endl;  
        }  
    private:  
        int x;  
    };  
    class B:public A  
    {  
    public:  
    B(int c,int b) :A(c) 
        {  
            y=b;  
            cout<<"B"<<endl;  
        }  
    B(int c)  
        {  
            y=c;  
            cout<<"Bb"<<endl;  
        }  
    private:  
        int y;  
    };  
    int main(void)  
    {  
        A *a=new B(2,3); 
        A *b=new B(2); 
        system("pause");  
        return 0;  
    } </span>


    执行结果A B Aa Bb

    展开全文
  • // 派生类的构造函数与基类的构造函数.cpp : Defines the entry point for the console application. //如果基类有构造函数,则在生成派生类的对象时会先调用基类的构造函数, //然后再调用派生类的构造函数。 #...
  • 怎样才能同时存在派生构造函数和基类构造函数 ``` public class constructor : baseclass { int varliable = new int();//相当于初始化为0 //此构造函数将调用 BaseClass.BaseClass() public constructor...
  • 派生构造函数

    2017-03-30 18:35:22
    2、 派生类的合成默认构造函数除了初始化派生类的数据成员之外,它还初始化派生类对象的基类部分。基类部分由基类的默认构造函数初始化。 3、 派生构造函数的初始化列表只能初始化派生类的成员,不能直接初始化...
  • 派生构造函数的一般形式为: 派生构造函数名(总参数表):基类构造函数名(参数表) { 派生类中新增加数据成员初始化语句 } 2.在建立一个对象时,执行构造函数的顺序是: a.派生构造函数先调用基类构造函数;...
  • 《Visual C++2012入门经典(第6版)》实例,在派生类的构造函数中调用基类的构造函数
  • 1.派生构造函数的一般形式为: 派生构造函数名(总参数表):基类构造函数名(参数表) { 派生类中新增加数据成员初始化语句 } 2.在建立一个对象时,执行构造函数的顺序是: a.派生构造函数先调用基类...
  • 构造函数 ,是一种特殊的方法 。主要用来在创建对象时初始化对象, 即为对象成员变量赋初始值,总与new运算符一起使用在创建对象的语句中 。特别的一个类可以有多个构造函数 ,可根据其参数个数的不同或参数类型的...
  • 派生类的构造函数

    2019-05-26 10:39:58
      前文我们谈到过构造函数《C++的构造函数》,现在我们主要讨论构造函数派生类里的运用。 1.必备知识/概念 继承与派生 派生构造函数的定义与声明 派生构造函数的功能 2.继承与派生     继承与派生其实...
  • C++派生构造函数实战.pdf
  • 多层派生是指:有一个基类A,派生出基类B,然后
  • 派生构造函数和析构函数的执行顺序
  • 派生构造函数 构造派生类对象流程:基类构造函数->派生构造函数 析构派生类对象流程:派生类析构函数->基类析构函数 派生类实际上是使用基类的构造函数来初始化其基类部分。 传递参数给基类构造函数...
  • C++派生类的构造函数构造函数的执行顺序)

    万次阅读 多人点赞 2018-06-16 16:01:55
    1、单继承时,派生构造函数总是先调用基类构造函数再执行其他代码 1.1 派生类调用基类的构造函数  类的构造函数不能被继承,构造函数不能被继承是有道理的,因为即使继承了,它的名字和派生类的名字也不一样,...
  • C++:派生类的默认构造函数和拷贝构造函数调用基类构造函数的机制(含程序验证) 1、如果基类定义了不带参数的默认构造函数,则编译器为派生类自动生成的默认构造函数会调用基类的默认构造函数。 2、如果基类定义...
  • 1 简单的派生类的构造函数的一般形式 为:  派生构造函数名(总参数表):基类构造函数名(参数表) {派生类中新增数据成员初始化语句} 2 有子对象的派生类的构造函数的一般形式为:  派生构造函数名...
  • 1.派生类的构造函数  当基类的构造函数没有参数,或没有显示定义构造函数时,派生类可以不向基类传递参数,甚至可以不定义构造函数.  当基类含有带参数的构造函数时,由于派生类不能继承基类的构造函数与析构...
  • 在进入派生类(derived)的拷贝构造函数之前,就已经调用了基类(based)的构造函数, 无论你有没有显示的调用。 一般派生类是这种形式: derived(const derived & d):based(d) {} 为什么使用下列形式不行 ...
  • C++派生构造函数执行次序: 调用基类构造函数,调用顺序为被继承时的顺序(左->右)对派生类的新增成员对象初始化,调用顺序是声明时的顺序。调用顺序都和初始化列表中的顺序无关
  • 《面向对象程序设计基础(第二版》李师贤等,第254页:C++语言的基本规则是:创建一个派生类的对象时,如果基类带有构造函数,则先调用基类的构造函数,然后才调用派生类的构造函数。  《Thinking in C++》,刘...
  • C++\测试 对象成员构造函数、基类构造函数派生类本身的构造函数 的先后顺序.rar
  • 通常情况下,默认构造函数系统会自动生成的,但是如果在基类中,我们自己定义了一个带参数的构造函数,这个时候,系统是不会为基类自动生成默认构造函数的,这个时候派生类则无法自动调用基类的默认构造函数了,因为...
  • C++派生类的构造函数

    千次阅读 2017-08-14 22:00:44
    派生类的构造函数 默认情况 基类的构造函数不被继承; 派生类需要定义自己的构造函数。 C++11规定 可用using语句继承基类构造函数。 但是只能初始化从基类继承的成员。 派生类新增成员可以通过类内初始值进行...
  • c++ 派生类的构造函数 与 基类构造函数的关系

    千次阅读 多人点赞 2019-05-22 10:35:00
    《面向对象程序设计基础(第二版》李师贤等,第254页:C++语言的基本规则是:创建一个派生类的对象时,如果基类带有构造函数,则先调用基类的构造函数,然后才调用派生类的构造函数。 《Thinking in C++》,刘宗田...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 151,564
精华内容 60,625
关键字:

派生构造函数