精华内容
下载资源
问答
  • C++构造函数调用顺序 千次阅读 多人点赞
    2019-06-24 09:49:26

    记忆原则,从“”出发,一层一层到要构造的类;
    析构函数则恰好相反
    C++构造函数按下列顺序被调用:
    (1)任何虚拟基类的构造函数按照它们被继承的顺序构造;
    (2)任何非虚拟基类的构造函数按照它们被继承的顺序构造;
    (3)任何成员对象的构造函数按照它们声明的顺序调用;
    (4)类自己的构造函数。

    #include <iostream>
    
    using namespace std;
    
    class OBJ1
    {
    public:
        OBJ1(){ cout <<"OBJ1\n"; }
    };
    
    class OBJ2
    {
    public:
        OBJ2(){ cout <<"OBJ2\n"; }
    };
    
    class Base1
    {
    public:
        Base1(){ cout <<"Base1\n"; }
    };
    
    class Base2
    {
    public:
        Base2(){ cout <<"Base2\n"; }
    };
    
    class Base3
    {
    public:
        Base3(){ cout <<"Base3\n"; }
    };
    
    class Base4
    {
    public:
        Base4(){ cout <<"Base4\n"; }
    };
    
    class Derived :public Base1, virtual public Base2,
        public Base3, virtual public Base4
    {
    public:
        Derived() :Base4(), Base3(), Base2(),
            Base1(), obj2(), obj1()
        {
            cout <<"Derived ok.\n";
        }
    protected:
        OBJ1 obj1;
        OBJ2 obj2;
    };
    
    int main()
    {
        Derived aa;
        cout <<"This is ok.\n";
    
        int i;
        cin >> i;
    
        return 0;
    }
    /*
    结果:
    Base2
    Base4
    Base1
    Base3
    OBJ1
    OBJ2
    Derived ok.
    This is ok.
    */
    
    更多相关内容
  • 继承构造函数调用顺序 C ++中带有继承的构造函数调用的顺序 (Order of Constructor Call with Inheritance in C++) Base class constructors are always called in the derived class constructors. Whenever you ...

    继承构造函数调用顺序

    Base class constructors are always called in the derived class constructors. Whenever you create derived class object, first the base class default constructor is executed and then the derived class's constructor finishes execution.

    基类构造函数总是在派生类构造函数中调用。 无论何时创建派生类对象,都将首先执行基类的默认构造函数,然后派生类的构造函数完成执行。

    要记住的要点 (Points to Remember)

    1. Whether derived class's default constructor is called or parameterised is called, base class's default constructor is always called inside them.

      无论是调用派生类的默认构造函数还是参数化,都始终在它们内部调用基类的默认构造函数。



    2. To call base class's parameterised constructor inside derived class's parameterised constructo, we must mention it explicitly while declaring derived class's parameterized constructor.

      要在派生类的参数化构造函数内部调用基类的参数化构造函数,必须在声明派生类的参数化构造函数时显式地提及它。

    派生类构造函数中的基类Default构造函数 (Base class Default Constructor in Derived class Constructors)

    Default constructor is present in all the classes. In the below example we will see when and why Base class's and Derived class's constructors are called.

    所有类中都存在默认构造函数。 在下面的示例中,我们将看到何时以及为什么调用基类和派生类的构造函数。

    class Base
    { 
        int x;
        public:
        // default constructor
        Base() 
        { 
            cout << "Base default constructor\n"; 
        }
    };
    
    class Derived : public Base
    { 
        int y;
        public:
        // default constructor
        Derived() 
        { 
            cout << "Derived default constructor\n"; 
        }
        // parameterized constructor
        Derived(int i) 
        { 
            cout << "Derived parameterized constructor\n"; 
        }
    };
    
    int main()
    {
        Base b;        
        Derived d1;    
        Derived d2(10);
    }

    Base default constructor Base default constructor Derived default constructor Base default constructor Derived parameterized constructor

    基本默认构造函数基本默认构造函数派生的默认构造函数基本默认构造函数派生的参数化构造函数

    You will see in the above example that with both the object creation of the Derived class, Base class's default constructor is called.

    在上面的示例中,您将看到在Derived类的两个对象创建过程中,都调用了Base类的默认构造函数。

    派生类构造函数中的基类参数化构造函数 (Base class Parameterized Constructor in Derived class Constructor)

    We can explicitly mention to call the Base class's parameterized constructor when Derived class's parameterized constructor is called.

    我们可以明确提到在调用派生类的参数化构造函数时调用基类的参数化构造函数。

    class Base
    { 
        int x;
        public:
        // parameterized constructor
        Base(int i)
        { 
            x = i;
            cout << "Base Parameterized Constructor\n";
        }
    };
    
    class Derived : public Base
    { 
        int y;
        public:
        // parameterized constructor
        Derived(int j):Base(j)
        { 
            y = j;
            cout << "Derived Parameterized Constructor\n";
        }
    };
    
    int main()
    {
        Derived d(10) ;
    }

    Base Parameterized Constructor Derived Parameterized Constructor

    基本参数化构造函数派生参数化构造函数

    为什么在派生类内部调用基类构造函数? (Why is Base class Constructor called inside Derived class?)

    Constructors have a special job of initializing the object properly. A Derived class constructor has access only to its own class members, but a Derived class object also have inherited property of Base class, and only base class constructor can properly initialize base class members. Hence all the constructors are called, else object wouldn't be constructed properly.

    构造函数有适当的初始化对象的特殊工作。 派生类构造函数只能访问其自己的类成员,但是派生类对象也具有基类的继承属性,并且只有基类构造函数才能正确初始化基类成员。 因此,将调用所有构造函数,否则将无法正确构造对象。

    C ++中的多重继承中的构造方法调用 (Constructor call in Multiple Inheritance in C++)

    Its almost the same, all the Base class's constructors are called inside derived class's constructor, in the same order in which they are inherited.

    几乎相同,所有基类的构造函数都在派生类的构造函数内部被调用,其继承顺序相同。

    class A : public B, public C ;

    In this case, first class B constructor will be executed, then class C constructor and then class A constructor.

    在这种情况下,将首先执行B类构造函数,然后是C类构造函数,然后是A类构造函数。

    翻译自: https://www.studytonight.com/cpp/order-of-constructor-call.php

    继承构造函数调用顺序

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

    千次阅读 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析构函数被调用


    展开全文
  • 子类与父类构造函数调用顺序

    千次阅读 2021-02-22 17:12:06
    子类与父类构造函数调用顺序 构造函数 当创建子类对象时, 构造函数的调用顺序: 静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数 注意: 无论创建几个对象, ...

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

    构造函数

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

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

      注意:

      无论创建几个对象, 该类的静态成员只构建一次, 所以静态成员的构造函数只调用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#构造函数调用顺序[归纳].pdf
  • C/C++---中多继承构造函数调用顺序

    千次阅读 2018-09-15 19:03:28
     //第四步:在初始化列表里找到memberB1(c),初始化一个B1对象,用c为参数,则调用B1的构造函数,打印"constB13"  //第五步:在初始化列表里找到memberB2(d),初始化一个B2对象,用d为参数,则调用B2的构造函数,...
  • c++ 子类父类 的构造函数调用顺序

    千次阅读 2017-09-01 21:40:25
    调用基类的构造函数,再调用派生类的构造函数 就像盖楼的时候先从地基开始,然后第一层,第二层。 如果是析构,那么先调用派生类的析构函数,再调用基类的析构函数 就像拆楼的时候想从最高层开始拆,然后往下...
  • 当派生类继承了基类,并且类中有基类对象作为成员变量时,构造函数调用顺序是怎样的呢? 看下面的程序: 派生类继承了两个基类A和B,主函数里定义了一个派生类对象: #include using namespace std; class A...
  • 关于父类与子类的构造函数调用顺序
  • C++ 虚继承对基类构造函数调用顺序的影响
  •  在说构造函数之前我们得先弄明白几个问题,首先是什么是类的构造函数,什么是类的成员对象,什么是基类,然后我们再来说构造函数调用顺序。  1、 类的构造函数  构造函数的功能主要用于在类的对象创建时定义...
  • 构造函数的执行次序如下: ...1,调用基类构造函数调用顺序按照他们的继承时声明的顺序。 2,调用内嵌成员对象的构造函数调用顺序按照他们在类中声明的 顺序。 3,派生类的构造函数体中的内容。
  • c++中构造函数调用顺序

    千次阅读 2020-12-16 17:59:39
    c++中构造函数调用顺序 C++中调用构造函数按照如下顺序: 一:先调用虚拟基类的构造函数。并且按照它们的被继承的顺序进行构造。 二:调用非虚拟基类的构造函数,也是按照它们被继承的顺序构造。 三:调用类中成员...
  • 子类父类构造函数调用顺序

    千次阅读 2017-01-18 20:43:48
    子类继承和调用父类的构造方法 1.如果子类没有定义构造方法,则调用父类的无参数的构造方法,. 2.如果子类定义了构造方法,不论是无参数还是带参数,在创建子类的对象的时候,首先执行父类无参数的构造方法,然后...
  • C++中若某类a从基类b、虚基类c派生而来,且该类中具有对象成员d,则在构造该类的对象时执行构造函数顺序? 构造一个类的对象的一般顺序是:class a:public b, virtual public c{}; 1.如果该类有直接或间接虚基类...
  • 构造函数调用顺序 子类会默认调用父类的无参构造方法; 子类的有参构造函数中没有super()方法时,不管子类是有参还是无参调用构造方法,都会先默认调用父类的无参构造方法; 有super()方法时会取消默认调用父类的...
  • 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类计算线段...
  • 在使用构造函数和析构函数时,需要特别注意对它们的调用时间和调用顺序。在一般情况下,调用析构函数的次序正好与调用构造函数的次序相反:最先被调用的构造函数,其对应的(同一对象中的)析构函数最后被调用,而最后...
  • 调用派生类的构造函数之前先调用基类的构造函数,析构函数则相反。因为派生类需要用到基类的成员,所以必须先有基类,再有派生类。   C++语法规定: 如果类没有显示定义构造函数,则编译器提供一个默认构造函数...
  • 我们先来建立一个父类,一个子类,一个子类的子类 ...实例化父类时,可以通过new子类来实例化父类,执行构造函数顺序为:先执行父类的构造函数,再执行子类的构造函数     再见
  • 前言: Hello,全世界早上好啊,哈哈,9月你好,2015年9月的第一天,也是...扯远了,往下的日子里,更要好好努力,今天以一道面试题为说起,理解或者说感受类中关于构造函数调用顺序问题: Let’s show the code
  • C++继承中构造函数调用顺序

    千次阅读 2013-04-14 21:37:06
    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 简单单继承 class Y {...} ...构造函数调用顺序是下面的顺序:
  • 构造函数和析构函数的调用顺序

    千次阅读 2019-09-03 15:47:29
    目录构造函数和析构函数构造函数复制构造函数析构函数构造函数与析构函数的调用顺序单继承多继承 构造函数和析构函数 构造函数 构造函数是特殊的成员函数,与类同名,没有返回类型,而且允许重载。如果没有为类显式...
  • C++中类的构造函数调用顺序

    千次阅读 2015-09-23 17:02:28
    当建立一个对象时,首先调用基类的构造函数,然后调用下一个派生类的构造函数,依次类推,直至到达派生类次数最多的派生次数最多的类的构造函数为止。简而言之,对象是由“底层向上”开始构造的。因为,构造函数一...
  • 静态变量在所在函数第一次被调用调用构造函数、在程序结束时调用析构函数,只调用一次。 局部变量在所在的代码段被执行时调用构造函数,在离开其所在作用域(大括号括起来的区域)时调用析构函数。可以调用任意多...
  • c++中 子类父类的构造函数调用顺序

    千次阅读 2014-03-18 21:50:00
    问题:创建一个对象调用构造函数的时候是从子类向父类调用还是从父类向子类调用 回答:1、对于构造函数,先调用基类的构造函数,再调用派生类的构造函数。就像盖楼的时候先从地基开始,然后第一层,第二层。。。 ...
  • Java构造函数调用顺序问题

    千次阅读 2017-06-07 19:18:15
    java构造代码调用顺序研究。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 393,769
精华内容 157,507
关键字:

构造函数调用顺序

友情链接: LPC2131_GPIO&TIMER_INT.zip