精华内容
下载资源
问答
  •  在说构造函数之前我们得先弄明白几个问题,首先是什么是类的构造函数,什么是类的成员对象,什么是基类,然后我们再来说构造函数调用顺序。  1、 类的构造函数  构造函数的功能主要用于在类的对象创建时定义...
  • 构造函数调用顺序

    千次阅读 2017-09-19 14:46:23
    构造函数调用顺序: class B1 { public: B1(int i){cout;} }; class B2 { public: B2(int j){cout;} }; class B3 { public: B3(){cout

    构造函数调用顺序:

      class B1
      {
      public:
    	B1(int i){cout<<"constructing B1"<<i<<endl;}
      };
      class B2
      {
      public:
    	B2(int j){cout<<"constructing B2"<<j<<endl;}
      };
      class B3
      {
    	public:
    	  B3(){cout<<"constructing B3*"<<endl;}
      };
      class C: public B2, public B1, public B3
      {
    	public:
    	  C(int a, int b, int c, intd):B1(a),memberB2(d),memberB1(c),B2(b){}
    	private:
    	  B1 memberB1;
    	  B2 memberB2;
    	  B3 memberB3;
      };
      void main( )
      { 
    		C obj(1,2,3,4); 
      }
      //运行后的结果如下:
      constructing B2 2
      constructing B1 1
      constructing B3 *
      constructing B1 3
      constructing B2 4
      constructing B3 *

    众所周知构造函数的执行次序如下:
      调用基类构造函数,调用顺序按照他们的继承时声明的顺序。
      调用内嵌成员对象的构造函数,调用顺序按照他们在类中声明的顺序。
      派生类的构造函数体中的内容。
      析构函数的调用顺序相反。

     那么再来看以上的例子就很容易理解了。B2、B1、B3是C的基类,按照上述的顺序,我们先要构造基类,然后才是子对象,最后是其本身的构造函数所以先要执行这三个类的构造函数。在构造时按照他们在类中的顺序,首先调用B2的构造函数
      B2(int j){cout<<"constructing B2"<<j<<endl;}
      由于在默认参数列表
      C(int a, int b, int c, intd):B1(a),memberB2(d),memberB1(c),B2(b){}
      中,将b的值传给了B2的构造函数,b为2,故打印出:
      constructing B2 2
      接下来要构造的是B1了。显然在C的默认参数构造列表中将a的值传给了B1,
      所以打印出:
      constructing B1 1
      B3在构造时没有传递参数,调用B3(){cout<<"constructing B3*"<<endl;}
      打印出:
     cout<<"constructing B3 *
      这时基类的构造函数已经执行完毕,接着该处理内嵌成员对象的构造函数了。
      我们看到C类有三个对象:B1 memberB1;B2 memberB2;B3memberB3;,按照构造函数的调用顺序,我们需要按照他们在类中声明的顺序来分别构造memberB1、memberB2、memberB3。在默认的参数列表中,用c来构造了memberB1,用d来构造memberB2,
      故打印出:
      constructing B1 3
      constructing B2 4
      constructing B3 *
      最后调用本身的构造函数,由于函数体为空,故什么也没有打印出来。
      总结 : 我们必须明确的是当一个类继承与基类,并且自身还包含有其他类的成员对象的时候,构造函数的调用顺序为:调用基类的构造函数->调用成员对象的构造函数->调用自身的构造函数。构造函数的调用次序完全不受构造函数初始化列表的表达式中的次序影响,与基类的声明次数和成员对象在函数中的声明次序有关
    再如:
    #include<iostream.h>
    class A
    {
    protected:
        char c;
    public:
        A(char ch)
        {
              c=ch;
               cout<<"c="<<c<<endl;
               cout<<"类A构造函数被调用"<<endl;
        }
        ~A()
        {
               cout<<"类A析构函数被调用"<<endl;
        }
    };
    class B
    {
    protected:
        int i;
    public:
        B(int j)
        {
               i=j;
               cout<<"i="<<i<<endl;
              cout<<"类B构造函数被调用"<<endl;
        }
        ~B()
        {
              cout<<"类B析构函数被调用"<<endl;
        }
    };
    class C:public A,B
    {
    private:
        int k;
    public:
        C(char ch,int ii,int kk):A(ch),B(ii),k(kk)
        {
              cout<<"k="<<k<<endl;
              cout<<"类C构造函数被调用"<<endl;
        }
        ~C()
        {
              cout<<"类C析构函数被调用"<<endl;
        }
    };
    void main()
    {
        C A('B',10,15);
    }
    //输出结果:
    c=B
    类A构造函数被调用
    i=10
    类B构造函数被调用
    k=15
    类C构造函数被调用
    类C析构函数被调用
    类B析构函数被调用
    类A析构函数被调用


    展开全文
  •  在说构造函数之前我们得先弄明白几个问题,首先是什么是类的构造函数,什么是类的成员对象,什么是基类,然后我们再来说构造函数调用顺序。  1、 类的构造函数  构造函数的功能主要用于在类的对象创建时定义...
  • 构造函数的执行次序如下: 1,调用基类构造函数调用顺序按照他们的继承时声明的顺序。...2,调用内嵌成员对象构造函数调用顺序按照他们在类中声明的 顺序。 3,派生类的构造函数体中的内容。
  • 下面小编就为大家带来一篇C++聚合关系类的构造函数调用顺序详解。小编觉得挺不错的,现在就分享给大家,也给大家做个参考,一起跟随小编过来看看吧
  • 关于类中对象成员构造函数和类自身构造函数的执行顺序的问题,我们通过一段简单的程序来验证,测试代码如下: #include <stdio.h> class A { public: A() { printf("AAAAA\n"); }; ~A(){}; ...

    关于类中对象成员的构造函数和类自身构造函数的执行顺序的问题,我们通过一段简单的程序来验证,测试代码如下:

    #include <stdio.h>
    
    class A
    {
    	public:
    		A()
    		{
    			printf("AAAAA\n"); 
    		};
    		~A(){};
    };
    
    class B
    {
    	public:
    		B()
    		{
    			printf("BBBBB\n"); 
    		};
    		~B(){};
    };
    
    class C
    {
    	public:
    		C()
    		{
    			printf("CCCCC\n"); 
    		};
    		~C(){};
    	private:
    		A m_a;
    		B m_b;
    };
    
    
    int main()
    {
    	C m_c;
    	return 0;
    } 

    执行结果如下:

     

    结论:优先执行各个成员对象的构造函数(按照声明的顺序依次执行),其次才是类自身的构造函数。

     

    展开全文
  • C++中类的构造函数调用顺序

    千次阅读 2015-09-23 17:02:28
    当建立一个对象时,首先调用基类的构造函数,然后调用下一个派生类的构造函数,依次类推,直至到达派生类次数最多的派生次数最多的类的构造函数为止。简而言之,对象是由“底层向上”开始构造的。因为,构造函数一...
    当建立一个对象时,首先调用基类的构造函数,然后调用下一个派生类的
    
    构造函数,依次类推,直至到达派生类次数最多的派生次数最多的类的构造函数为止。
    简而言之,对象是由“底层向上”开始构造的。因为,构造函数一开始构造时,总是
    要调用它的基类的构造函数,然后才开始执行其构造函数体,调用直接基类构造函数时,
    如果无专门说明,就调用直接基类的默认构造函数。在对象析构时,其顺序正好相反。

    下面的这个程序说明这个问题


    总结下来,我们必须明确的是当一个类继承与基类,并且自身还包含有其他类的成员对象的时候,构造函数的调用顺序为:调用基类的构造函数->调用成员对象的构造函数->调用自身的构造函数构造函数的调用次序完全不受构造函数初始化列表的表达式中的次序影响,与基类的声明次数和成员对象在函数中的声明次序有关


    1. C++子类和父类的构造函数调用顺序
    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. //子类  
    5. class base  
    6. {  
    7. public:  
    8.     base()  
    9.     {  
    10.         cout<<"i am base constuction!"<<endl;  
    11.     }  
    12. };  
    13. //父类  
    14. class drived : public base  
    15. {  
    16. public:  
    17.     drived()  
    18.     {  
    19.         cout<<"i am drived constuction!"<<endl;  
    20.     }  
    21. };  
    22. int main()  
    23. {  
    24.     drived d;  
    25.     //输出结果  
    26.     /* 
    27.     i am base constuction! 
    28.     i am drived constuction! 
    29.     Press any key to continue 
    30.     */  
    31.     return 0;  
    32. }  

    由输出结果我们可以看到,先调用的是base类的构造函数,再调用了drived类的构造函数,也就是说,在声明子类实例的时候,是会先调用父类的构造函数的。这个很好理解,子类是包含了父类的信息的,所以要构造子类,必须先构造父类的信息,然后加入一些子类的新信息。

    成员类的构造函数调用顺序
    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class son  
    5.     {  
    6.     public:  
    7.         son()  
    8.         {  
    9.             cout<<"i am son constuction!"<<endl;  
    10.         }  
    11.     };  
    12. class family  
    13. {  
    14. public:  
    15.     family()  
    16.     {  
    17.         cout<<"i am family constuction!"<<endl;  
    18.     }  
    19.     son jack;  
    20.       
    21. };  
    22.   
    23.   
    24. int main()  
    25. {  
    26.     family happyfamily;  
    27.     //输出结果  
    28.     /* 
    29.     i am son constuction! 
    30.     i am family constuction! 
    31.     Press any key to continue 
    32.  
    33.     */  
    34.     return 0;  
    35. }  

    从上面的结果我们科看到,先调用的是构造函数。这是为什么?因为类中含有成员类时,先要给成员类申请空间,先调用成员类的构造函数,然后再调用自身的构造函数。

    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3. //父亲姓名  
    4. class name  
    5. {  
    6. public:  
    7.     name()  
    8.     {  
    9.         cout<<"i am name constuction!"<<endl;  
    10.     }  
    11. };  
    12. //子类  
    13. class base  
    14. {  
    15. public:  
    16.     base()  
    17.     {  
    18.         cout<<"i am base constuction!"<<endl;  
    19.     }  
    20. };  
    21. //父类  
    22. class drived : public base  
    23. {  
    24. public:  
    25.     drived()  
    26.     {  
    27.         cout<<"i am drived constuction!"<<endl;  
    28.     }  
    29.     name drivedname;  
    30. };  
    31.   
    32. int main()  
    33. {  
    34.     drived d;  
    35.     //输出结果  
    36.     /* 
    37.     i am base constuction! 
    38.     i am name constuction! 
    39.     i am drived constuction! 
    40.     Press any key to continue 
    41.  
    42.     */  
    43.     return 0;  
    44. }  

    上面的例子是声明了一个name类,一个base类,一个drived类,其中drived类是从base类派生,且drived类中声明了name类的一个实例。
    那么根据我们上面的分析,我们声明了drived类之后,先会调用父类构造函数,也就是输出i am base construction,然后调用自身的成员类构造函数,也就是i am name construction,最后调用自身的构造函数,也就是i am drived construction。
    同理,如果我们在父类base类中声明了name成员类的话,顺序会是name->base->drived。我下面给出测试例子:
    [cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
    1. #include <iostream>  
    2. using namespace std;  
    3. //父亲姓名  
    4. class name  
    5. {  
    6. public:  
    7.     name()  
    8.     {  
    9.         cout<<"i am name constuction!"<<endl;  
    10.     }  
    11. };  
    12. //子类  
    13. class base  
    14. {  
    15. public:  
    16.     base()  
    17.     {  
    18.         cout<<"i am base constuction!"<<endl;  
    19.     }  
    20.     name drivedname;  
    21. };  
    22. //父类  
    23. class drived : public base  
    24. {  
    25. public:  
    26.     drived()  
    27.     {  
    28.         cout<<"i am drived constuction!"<<endl;  
    29.     }  
    30.       
    31. };  
    32.   
    33. int main()  
    34. {  
    35.     drived d;  
    36.     //输出结果  
    37.     /* 
    38.     i am name constuction! 
    39.     i am base constuction! 
    40.     i am drived constuction! 
    41.     Press any key to continue 
    42.     */  
    43.     return 0;  
    44. }  


    展开全文
  • 子类与父类构造函数调用顺序 构造函数 当创建子类对象时, 构造函数的调用顺序: 静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数 注意: 无论创建几个对象, ...

    子类与父类构造函数调用顺序

    构造函数

    • 当创建子类对象时, 构造函数的调用顺序:

      静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数

      注意:

      无论创建几个对象, 该类的静态成员只构建一次, 所以静态成员的构造函数只调用1次!!!

    析构函数

    子类的析构函数的调用顺序,和子类的构造函数的调用顺序相反!!!

    记住,相反即可。

    #include <iostream>
    #include <Windows.h>
    
    using namespace std;
    
    class M {
    public:
    	M() {
    		cout << __FUNCTION__ << endl;
    	}
    
    	~M() {
    		cout << __FUNCTION__ << endl;
    	}
    };
    
    class N {
    public:
    	N() {
    		cout << __FUNCTION__ << endl;
    	}
    
    	~N() {
    		cout << __FUNCTION__ << endl;
    	}
    };
    
    class A {
    public:
    	A() {
    		cout << __FUNCTION__ << endl;
    	}
    
    	~A() {
    		cout << __FUNCTION__ << endl;
    	}
    };
    
    class B : public A {
    public:
    	B() {
    		cout << __FUNCTION__ << endl;
    	}
    
    	~B() {
    		cout << __FUNCTION__ << endl;
    	}
    private:
    	M m1;
    	M m2;
    	static N ms;
    };
    
    N B::ms;  //静态成员
    
    int main(void) {
    	{
    		B b;
    		cout << endl;
    	}
    
    	system("pause");
    }
    

    执行:
    //调用构造
    N::N
    A::A
    M::M
    M::M
    B::B

    //调用析构
    B::~B
    M::~M
    M::~M
    A::~A
    静态对象在程序终止时被销毁,所以:
    静态成员的析构函数,在程序结束前,是不会被调用的!

    展开全文
  • C++构造函数调用顺序

    千次阅读 多人点赞 2019-06-24 09:49:26
    C++构造函数按下列顺序调用: ...(3)任何成员对象构造函数按照它们声明的顺序调用; (4)类自己的构造函数。 #include <iostream> using namespace std; class OBJ1 { public: OBJ1(){ cout...
  • 在使用构造函数和析构函数时,需要特别注意对它们的调用时间和调用顺序。在一般情况下,调用析构函数的次序正好与调用构造函数的次序相反:最先被调用的构造函数,其对应的(同一对象中的)析构函数最后被调用,而最后...
  • 前言: Hello,全世界早上好啊,哈哈,9月你好,2015年9月的第一天,也是...扯远了,往下的日子里,更要好好努力,今天以一道面试题为说起,理解或者说感受类中关于构造函数调用顺序问题: Let’s show the code
  • 创建派生类对象构造函数的执行顺序

    万次阅读 多人点赞 2019-04-24 22:04:10
    A 基类构造函数,派生类对象成员构造函数,派生类本身的构造函数 B 派生类本身的构造函数,基类构造函数,对象成员构造函数 C 基类构造函数,派生类本身的构造函数,派生类对象成员构造函数 D 对象成员构造...
  • 构造函数和析构函数的调用顺序

    千次阅读 2019-09-03 15:47:29
    目录构造函数和析构函数构造函数复制构造函数析构函数构造函数与析构函数的调用顺序单继承多继承 构造函数和析构函数 构造函数 构造函数是特殊的成员函数,与类同名,没有返回类型,而且允许重载。如果没有为类显式...
  • C++中建立派生类对象构造函数调用顺序 建立派生类对象时,派生类构造函数调用顺序如下: 执行基类的构造函数。当派生类有多个基类时,处于同一层次的各个基类的构造函数调用顺序取决于定义派生类时...
  • C-组合类中构造函数调用顺序

    千次阅读 多人点赞 2019-07-25 18:02:08
    title: C++组合类中构造函数调用顺序 date: 2019-07-25 14:43:50 tags: C++ 类(class) categories: C++基础 以线段(Line)类为例子,梳理C++组合类中构造函数调用顺序。 Line类源程序 //Line类计算线段...
  • 一、派生类对象中基类构造函数和派生类中构造函数调用顺序(WIN7 64位 VS2012) (1)、先执行派生类的构造函数还是先执行基类中的构造函数? 利用下面这段代码进行打印测试 #include using namespace std; // 基类 ...
  • 派生类的构造函数与析构函数的调用顺序 前面已经提到,构造函数和析构函数的调用顺序是先构造的后析构,后构造的先析构。 那么基类和派生类中的构造函数和析构函数的调用顺序是否也是如此呢? 构造函数调用...
  • 测试: #include #include #include #include #include #include #include using namespace std; class member1{ public: member1(){ cout !" ; } ~membe
  • 打印结果:对象初始化时候,先对类成员变量分配空间和和初始化,然后调用构造函数(和public、private无关),对象析构时相反所以这里对于创建a对象直接调用A的构造函数,创建b对象的时候先对成员B类的成员变量进行...
  • 近期在网上搜寻了一下关于C++派生类构造函数调用问题,大部分博文给出的顺序是: 1、基类构造 2、成员构造 3、派生构造。 这个顺序严格来讲是错误的,对新手极具误导性!  依据侯捷翻译的Stanley B. Lippman...
  • ![![![![图片说明](https://img-ask.csdn.net/upload/201703/29/1490796134_354787.png)图片说明](https://img-ask.csdn.net/upload/201703/29/1490796115_685272.png)图片说明](http:![![图片说明]...
  • C++对象成员构造函数

    千次阅读 2018-03-19 20:47:35
    当一个类中出现对象成员时,该类的构造函数就要为对象成员初始化,对象成员的初始化必须在构造函数的初始化表中完成。注意:初始化对象成员时必须用对象成员名,而不是它的类型名。例如:class Date{ int year, ...
  • 对于派生类的构造 函数,在定义对象构造函数的执行顺序为: 1:基类的构造函数 2:成员对象构造函数 3:派生类本身的构造函数 public class IoTest { public static void main(String[] args) throws ...
  • 构造函数调用顺序:基类 --> 数据成员对象(基于声明的顺序) --> 子类; 析构函数的调用顺序则相反。   #include using namespace std; class human { public: human(int height=0, int weight=0) ...
  • 顺序上:先调用成员对象构造函数,当所有的成员对象都执行了自身类的构造函数以后再执行当前类的构造函数 调用析构函数时先调用类的构造函数,再调用成员对象构造函数。 例如: #include<iostream> ...
  • C/C++---中多继承构造函数调用顺序

    千次阅读 2018-09-15 19:03:28
     //第四步:在初始化列表里找到memberB1(c),初始化一个B1对象,用c为参数,则调用B1的构造函数,打印"constB13"  //第五步:在初始化列表里找到memberB2(d),初始化一个B2对象,用d为参数,则调用B2的构造函数,...
  • 1.按在组合类的定义中出现的顺序调用内嵌对象构造函数(与初始化列表中出现的顺序无关) 2.调用本类构造函数的函数体 组合类构造函数定义的一般形式一般为: 类名::类名(形参表):内嵌对象1(形参表),内嵌...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 156,987
精华内容 62,794
关键字:

关于对象成员的构造函数的调用顺序