精华内容
下载资源
问答
  • 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++中类的默认构造函数调用的时机

    千次阅读 2020-11-17 11:06:28
    当不使用任何初始值定义一个类的非静态变量时,会调用该类的默认构造函数。 Aa; 此时,会调用类A的默认构造函数。在《C++中类的合成默认构造函数2-1》https://blog.csdn.net/hou09tian/article/details/108072603...

    1 不指定类对象的初始值时

    当不使用任何初始值定义一个类的非静态变量时,会调用该类的默认构造函数。

    A a;

    此时,会调用类A的默认构造函数。在《C++中类的合成默认构造函数2-1》https://blog.csdn.net/hou09tian/article/details/108072603中提到,如果类中没有显式地定义默认构造函数,则C++编译器会为其创造一个合成的默认构造函数,如果类中已经定义了其他格式的构造函数,此时C++编译器不会再为其合成默认构造函数。所以,如果此时类A的定义为

    class A {
    public:
      A(int i){}
    };

    此时,程序会报错,报错信息为“error C2512: “A”: 没有合适的默认构造函数可用”。

    2 类本身含有类的对象且使用该类的默认构造函数时

    当类B含有类A的对象,并且使用类B的默认构造函数时,会调用类A的默认构造函数。

    class A {
      public:
        A(int i){}
    };
    
    class B {
      A m_a;
    };

    使用类B的默认构造函数来创建该类的对象

    B b;

    此时,会调用类B的合成默认构造函数,并调用类A的默认构造函数。因为类A没有默认构造函数,所以此时程序报错信息为“ error C2280: “B::B(void)”: 尝试引用已删除的函数”。

    3 类本身含有类的对象且没有在构造函数中显式初始化该对象时

     

    class A {
      public:
        A(int i){}
    };
    
    class B {
      public:
        B(int i){
    }
        A m_a;
    };

    此时,类B的构造函数没有显式地初始化类A的对象m_a,那么则需要调用类A的默认构造函数来初始化m_a,但是类A没有定义默认构造函数,因此,程序的报错信息为“ error C2512: “A”: 没有合适的默认构造函数可用”。

    展开全文
  • 主要介绍了C++类继承之子类调用父类的构造函数的实例详解的相关资料,希望通过本文大家能够掌握C++类继承的相关知识,需要的朋友可以参考下
  • 子类与父类构造函数调用顺序

    千次阅读 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
    静态对象在程序终止时被销毁,所以:
    静态成员的析构函数,在程序结束前,是不会被调用的!

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

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


    展开全文
  • 【C/C++】构造函数调用次数

    千次阅读 多人点赞 2019-09-03 21:32:21
    构造函数调用次数 关于构造函数的调用次数,这里有个小总结: 简单粗暴 测试代码: #include <iostream> using namespace std; class Test{ int a; public: Test(){ a = 0; cout << ...
  • 关于构造函数调用次数

    千次阅读 多人点赞 2019-05-30 15:12:50
    MyClass a:定义一个对象,调用1次构造函数。 b[2]:定义含有两个元素的数组,实际上定义两个对象,所以调用2次构造函数。 *c:定义指向类对象的指针,但没有进行实际的内存分配,所以不调用构造函数。 **d:定义...
  • c#构造函数调用含参构造函数

    千次阅读 2018-10-25 09:20:17
    话不多说,直接上代码: public class Test ...经过代码测试知道上面的含参构造函数在第一个构造函数调用的,冒号后面为传的参数的值,构造函数没有返回值,这样便实现了实例化类时给类的属性赋值。
  • 正确调用的方式是: 摘自:https://blog.csdn.net/aa18316/article/details/101884616
  • 因为构造函数是公有的,所以理所当然地会被子类继承。 程序1: #include &lt;iostream&gt; using namespace std; class Shape { public: Shape() { cout &lt;&lt; "Shape's ...
  • C++中构造函数调用其他函数

    千次阅读 2013-08-30 16:43:55
    1)在c++里,由于构造函数允许有默认参数,使得这种构造函数调用构造函数来重用代码的需求大为减少 2)如果仅仅为了一个构造函数重用另一个构造函数的代码,那么完全可以把构造函数中的公共部分抽取出来定义一个...
  • C++中类的构造函数调用顺序

    千次阅读 2015-09-23 17:02:28
    当建立一个对象时,首先调用基类的构造函数,然后调用下一个派生类的构造函数,依次类推,直至到达派生类次数最多的派生次数最多的类的构造函数为止。简而言之,对象是由“底层向上”开始构造的。因为,构造函数一...
  • 关于父类与子类的构造函数调用顺序
  • java构造函数调用构造函数

    千次阅读 2014-04-26 15:01:57
    一个类可包含多个构造函数,在java中一个构造函数可以
  • C/C++---中多继承构造函数调用顺序

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

    千次阅读 2017-02-21 22:40:06
    若一个类中有静态构造函数,在首次实例化该类或任何的静态成员被引用时,.NET自动调用静态构造函数来初始化该类。注意是“首次”,即继续实例化该类时,不会调用该类的静态构造函数。1、实例化时调用静态构造函数 //...
  • c++ 子类父类 的构造函数调用顺序

    千次阅读 2017-09-01 21:40:25
    调用基类的构造函数,再调用派生类的构造函数 就像盖楼的时候先从地基开始,然后第一层,第二层。 如果是析构,那么先调用派生类的析构函数,再调用基类的析构函数 就像拆楼的时候想从最高层开始拆,然后往下...
  • #include using namespace std; struct CLS { int m_i; CLS(int i) : m_i(i) { cout(): this=";...可以看到,在带参数的构造函数里打印出来的对象地址 ...构造函数的互相调用引起的后果不是死循环 而是栈溢出 */
  • 子类父类构造函数调用顺序

    千次阅读 2017-01-18 20:43:48
    子类继承和调用父类的构造方法 1.如果子类没有定义构造方法,则调用父类的无参数的构造方法,. 2.如果子类定义了构造方法,不论是无参数还是带参数,在创建子类的对象的时候,首先执行父类无参数的构造方法,然后...
  • 上面类中,已经有一个构造函数,形参有两个,我们又重载一个有3个形参的构造函数,为了减少代码量,就想着让3个参数的构造函数调用2个参数的构造函数,然后在执行一些自己的代码,这就如同派生类先调用基类的同名...
  • 前言: Hello,全世界早上好啊,哈哈,9月你好,2015年9月的第一天,也是...扯远了,往下的日子里,更要好好努力,今天以一道面试题为说起,理解或者说感受类中关于构造函数调用顺序问题: Let’s show the code
  • 构造函数调用次数

    千次阅读 2016-09-19 23:54:12
    #include #include using namespace std; class A { public: A() { cout } }; ... //调用两次构造函数 //A a; return 0; } //output 构造函数 构造函数 请按任意键继续. . .
  • 如何在Java中调用另一个构造函数

    千次阅读 2021-02-12 21:41:19
    是否可以从另一个(在同一个类中,而不是从子类中)调用构造函数? 如果有,怎么样? 什么是调用另一个构造函数的最佳方法(如果有几种方法可以做到)?18个解决方案2568 votes对的,这是可能的:public class Foo {...
  • Java构造函数调用构造函数

    千次阅读 2019-07-22 23:44:39
    在Java中,当为一个类创建了多个构造函数时,有时想在一个构造函数调用另一个构造函数以减少代码量。这时可以使用this关键字来实现。通常,当使用this关键字时,它意味着“这个对象”或者“当前对象”,并且它自身...
  • 构造函数调用虚函数

    千次阅读 2019-07-19 15:44:02
    调用B的构造函数,先调用A的构造函数调用A的构造函数,先按照A对象的内存布局进行初始化,因为虚表指针是放在顶部的,先初始化虚表指针,指向虚表(虚表在编译期就生成),之后按照声明顺序初始化成员变量。...
  • java构造函数调用

    千次阅读 2018-11-09 01:35:42
    构造函数调用,需要使用this关键字 this(); //调用无参构造函数Food() this(name); //调用有参构造函数Food(String name) 作用: 在一个构造函数调用另一个构造函数,主要是为了增加代码的复用性。 ...
  • C#构造函数调用其他构造函数(转)

    千次阅读 2017-09-14 14:25:19
    其实就是使用this来实现的。看一下例子就会明白的了。 class Class1 { public Class1() { //Code 1 } public Class1(string s) : this() { //Code 2 } public Class1(int i, string j) ...希望对
  • C++ 如何在类的构造函数调用已经写好的构造函数 让我们先看一段代码: #include<iostream> using namespace std; int main() { int a = 12; cout << a << endl; int* p = new (&a) int(15...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,312,448
精华内容 524,979
关键字:

构造函数的调用