精华内容
下载资源
问答
  • 析构顺序
    2021-10-28 17:20:37

    类的包含与继承析构顺序相反:

    1、继承关系:子类与父类在析构时,先析构子类再析构父类
    2、包含关系:类与类的成员变量在析构时,先执行类的析构函数再执行成员变量的析构

    更多相关内容
  • 本篇文章是对c++中参数对象与局部对象的析构顺序进行了详细的分析介绍,需要的朋友参考下
  • 继承关系上构造析构顺序 C++类成员变量初始化顺序: 基类的静态变量 派生类的静态变量 基类的成员变量 派生类的成员变量 类变量按照列出的顺序初始化,然后以相反的顺序销毁 多重继承的构造顺序:基类→子对象...

    继承关系上构造析构顺序

    • 有类静态成员变量优先构造静态变量
      • 与声明的顺序无关,与继承关系也无关,只是按照定义的先后顺序构造。
    • 先调用基类的构造
      • 先构造基类成员变量
      • 基类本身的构造函数
    • 然后再是派生类
      • 先构造派生类成员变量
      • 派生类本身的构造函数

    同一级别的构造顺序

    1. 类静态成员与声明的顺序无关,与继承关系也无关,根据定义的先后顺序初始化
    2. 类普通成员变量按照定义的顺序初始化
    3. 继承关系则是根据继承的先后顺序初始化
    4. 有虚函数的先初始化虚表指针
    5. 执行初始化列表
    6. 执行构造函数

    示例:

    #include <iostream>
    
    using namespace std;
    
    class Base
    {
    public:
       virtual int size() 
       {
           cout << "Base::size" << endl;
           return 22; 
       }
    };
    
    
    class A :public Base
    {
    public:
       int m_a = -1;
       A() :m_a(size())   //在初始化列表中调用了虚函数
       {
           cout << "in A() m_a is " <<  m_a << endl;
       }
       virtual int size() 
       {
           cout << "A::size" << endl;
           return 11;
       }
    };
    
    int main()
    {
       A a;
       return 0;
    }
    

    output:

    A::size
    in A() m_a is 11
    

    析构的顺序则刚好是构造顺序的逆序

    示例:

    #include<iostream>
    
    using namespace std;
    
    class C
    {
    public:
        C() { cout << "in C()" << endl; }
        ~C() { cout << "in ~C()" << endl; }
    };
    
    class D
    {
    public:
        D() { cout << "in D()" << endl; }
        ~D() { cout << "in ~D()" << endl; }
    };
    
    class StaticA
    {
    public:
        StaticA() { cout << "in StaticA()" << endl; }
        ~StaticA() { cout << "in ~StaticA()" << endl; }
    };
    
    class StaticB
    {
    public:
        StaticB() { cout << "in StaticB()" << endl; }
        ~StaticB() { cout << "in ~StaticB()" << endl; }
    };
    
    class A
    {
    public:
        int a;
        int b = -1;
        C c;
        static StaticB sb; // 只是声明静态成员,并没有定义,也没有初始化。不占内存。
        static StaticA sa;
        static D d;
    public:
        A() :b(0), a(b + 2) { cout << "in A()" << endl; }
        ~A() { cout << "in ~A()" << endl; }
        void print()
        {
            cout << "a = " << a << " ,b = " << b << endl;
        }
    };
    
    StaticB A::sb;
    StaticA A::sa; // 这里才是定义,同时可以在这里初始化
    
    class E
    {
    public:
        E() { cout << "in E()" << endl; }
        ~E() { cout << "in ~E()" << endl; }
    };
    
    class F
    {
    public:
        F() { cout << "in F()" << endl; }
        ~F() { cout << "in ~F()" << endl; }
    };
    
    class B : public E, public A
    {
    public:
        B() { cout << "in B()" << endl; }
        ~B() { cout << "in ~B()" << endl; }
    
    private:
        D d;
        static StaticB sb;
    };
    
    StaticB B::sb;
    D A::d;
    
    int main()
    {
        cout << "test start" << endl;
        {
            B b;
            static F f;
        }
        cout << "test end" << endl;
        return 0;
    }
    

    output

    in StaticB()
    in StaticA()
    in StaticB()
    in D()
    test start
    in E()
    in C()
    in A()
    in D()
    in B()
    in F()
    in ~B()
    in ~D()
    in ~A()
    in ~C()
    in ~E()
    test end
    in ~F()
    in ~D()
    in ~StaticB()
    in ~StaticA()
    in ~StaticB()
    

    其中

    • 类static成员变量的生命周期和程序的生命周期是相同的
    • static局部变量则在第一次访问时构造,直到程序结束。
    展开全文
  • 下面是c++的源码: class X { public:  int i;  int j;  ~X() {}   }; void f(X x) {  X x1;  x.i = 1;  x.j = 2;   } int main() { ...为临时对象预留8byte空间,由于没有显示定义
  • C++类构造及析构顺序

    2021-08-24 10:14:54
    构造行为以及顺序 ...析构行为以及顺序 1.析构函数本体被执行(用户代码) 2.数据成员的析构函数,以声明顺序的逆序(如果有) 3.虚表指针被重设指向上一层基类虚表(如果有) 4.上一层非虚基类析构函数

    构造行为以及顺序
    1.虚基类构造函数被调用,以继承顺序从左到右(如果存在虚基类)
    2.上一层非虚基类构造函数被调用,以继承顺序从左到右而非成员初值列上写的顺序;显示调用或默认构造(如果存在非虚基类)
    3.虚表指针指向适当虚表(如果类存在虚表指针)
    4.类数据成员初始化,以声明的顺序而非成员初值列上写的顺序。
    5.执行用户所写代码

    析构行为以及顺序
    1.析构函数本体被执行(用户代码)
    2.数据成员的析构函数,以声明顺序的逆序(如果有)
    3.虚表指针被重设指向上一层基类虚表(如果有)
    4.上一层非虚基类析构函数被调用,以继承顺序的逆序
    5.如果当前析构的类是最尾端的类且有虚基类,调用虚基类析构函数

    资料来源
    《深入探索C++对象模型》
    ————————————————
    版权声明:本文为CSDN博主「code world」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
    原文链接:https://blog.csdn.net/baidu_41728493/article/details/108324219

    展开全文
  • 8.2 析构顺序与构造顺序相反 8.3 子类是不会继承父类的构造函数和析构函数 8.4 补充内容,如果父类中没有合适默认构造,那么子类可以利用初始化列表的方式显示的调用父类的其他构造 #define _CRT_SECURE_NO_WARNINGS...

    8.1 子类创建对象时,先调用父类的构造,然后调用自身构造
    8.2 析构顺序与构造顺序相反
    8.3 子类是不会继承父类的构造函数和析构函数
    8.4 补充内容,如果父类中没有合适默认构造,那么子类可以利用初始化列表的方式显示的调用父类的其他构造

    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<string>
    using namespace std;
    
    class Modulator {
    public:
    	Modulator() {
    		cout << "Modulator默认构造函数调用" << endl;
    	}
    	~Modulator() {
    		cout << "Modulator的析构函数调用" << endl;
    	}
    };
    
    class Demodulator:public Modulator {
    public:
    	Demodulator() {
    		cout << "Demodulator默认构造函数调用" << endl;
    	}
    	~Demodulator() {
    		cout << "Demodulator的析构函数调用" << endl;
    	}
    };
    
    void test01() {
    	Demodulator dem;
    }
    int main(){
    	test01();
    	
    	system("pause");
    	return 0;
    }
    

    在这里插入图片描述

    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<string>
    using namespace std;
    
    class Modulator {
    public:
    	Modulator(int a) {
    		this->m_a = a;
    		cout << "Modulator默认构造函数调用" << endl;
    	}
    	~Modulator() {
    		cout << "Modulator的析构函数调用" << endl;
    	}
    	
    	int m_a;
    };
    
    // 子类会继承父类的成员属性,成员函数
    //但是 子类 不会继承 父类 构造函数 和 析构函数
    //只有父类自己知道如果构造和析构自己的属性,而子类不知道
    
    class Demodulator :public Modulator {
    public:
    	Demodulator(int a) :Modulator(a){ //利用初始化列表方式 显示调用 有参构造
    		cout << "Demodulator默认构造函数调用" << endl;
    	}
    	~Demodulator() {
    		cout << "Demodulator的析构函数调用" << endl;
    	}
    };
    
    void test01() {
    	Demodulator dem(26);
    }
    int main() {
    	test01();
    
    	system("pause");
    	return 0;
    }
    
    展开全文
  • 由于全局对象可能在文件中的不同地方被调用,因此编译器会优先编译全局对象,也就是说,全局对象先于主函数产生,放在全局区(或称静态区,地址由低到高),待整个程序运行完后析构释放。 静态对象: 静态对象只...
  • #include<iostream> #include<string> using namespace std; class Father {//父类 public: Father() { cout << "Father start" << endl; } ~Father() { cout <...pu
  • 问题:父类和子类的构造 析构函数的顺序 谁先谁后? #include<iostream> using namespace std; class Base { public: Base() { cout << "Base构造函数!" << endl; } ~Base() { cout <...
  • 类的构造与析构顺序

    2020-11-17 21:11:45
    首先,我们来看一段代码: #include using namespace std; class A { public: A() { cout ; } ~A() { cout ; } };... (4)以上所有对象的析构函数以与构造函数的执行顺序相反的顺序执行。
  • C++中对象的构造顺序和析构顺序

    千次阅读 2020-02-04 11:23:25
    文章目录1 C++中对象的构造顺序1.1 局部对象的构造顺序1.2 堆对象的构造顺序1.3 全局对象的构造顺序 1 C++中对象的构造顺序 C++中的类可以定义多个对象,那么对象构造的顺序是怎样的? 1.1 局部对象的构造顺序 ...
  • 对象的析构顺序

    2021-03-08 11:42:12
    笔记:多个对象在同一作用域内即将消亡时**,先定义的后析构**,满足一个栈的管理; eg: #include <iostream> using namespace std; class Test { private: int *p; public: Test(int tmp) { this->...
  • C++理解(1)–c++中的对象的构造顺序与析构顺序 问题:当程序中存在多个对象时,如何确定这些对象的析构顺序? 一.单个函数创建时构造函数的调用顺序 1.调用父类的构造过程 2.调用成员变量的构造函数(调用顺序与...
  • 2.继承中先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反 #include<iostream> using namespace std; #include<string> //继承中的构造和析构顺序 class Base { public: Base() { ...
  • 类的构造析构顺序

    2020-09-09 11:42:47
    析构顺序:与构造相反 #include <iostream> using namespace std; class A { public: A(){cout << "A()" << endl;} ~A(){cout << "~A()"" << endl;} } class B { public: B(){cout...
  • C++ 类成员的构造和析构顺序

    千次阅读 2021-02-13 16:11:39
    C++ 对象 成员 构造 析构 顺序
  • 继承 之 构造析构顺序 #include<iostream> using namespace std; class parent { public: parent(int a, int b) { this->a = a; this->b = b; cout << "我是爸爸构造函数" << ...
  • 第一层:理解一个类内部各个数据成员之间的构造/析构顺序。这里需要注意的是,数据成员的构造顺序与其在类中声明的顺序相同,而无论构造函数中初始化列表中的顺序,这个不难; 第二层:理解基类和派生类之间的构造/...
  • C++对象构造析构顺序

    2019-08-04 12:52:05
    类的构造和析构顺序结果为 由结果可见,全局对象B先进行构造,然后ADC按定义顺序进行构造。 析构的时候先析构局部对象,按照先构造后析构的顺序D、A进行析构。存在栈上。 再析构静态对象和全局对象C、B。因为B和C...
  • 构造顺序与析构顺序

    千次阅读 2019-03-19 10:33:25
    1. 调用基类构造函数,调用顺序按照它们被继承时声明的顺序(从左到右); 2. 调用内嵌成员对象的构造函数,调用顺序按照它们在类中声明的顺序; 3. 派生类自己构造函数体中的内容。 派生类析构函数执行的次序: ...
  • 不过,对象树中对象的顺序是没有定义的。这意味着,销毁这些对象的顺序也是未定义的。Qt 保证的是,任何对象树中的 QObject 对象 delete 的时候,如果这个对象有 parent,则自动将其从 parent 的 children() 列表中...
  • C++全局变量与静态变量的构造与析构顺序 本人是C++的初学者,将自己学习过程中的一些收获记录在CSDN上,一方面能为大家提供帮助,另一方面能够方便自己日后查看。 关于在C++全局变量与静态变量的构造与析构顺序,...
  • c++基类和派生类析构顺序

    千次阅读 2019-03-05 16:41:40
    class father{ public: father() { qDebug(); } ~father() { qDebug(); } }; class son :public father ...delete: 顺序同new反过来 先调用派生类的析构 在 基类的 析构 一层一层的
  • 1、讲解当类对象做成员时的构造函数与析构函数的执行顺序; 2、演示包含类内对象的项目开发过程;
  • C++的构造和析构顺序

    千次阅读 2018-01-30 10:07:03
    子类的构造和析构过程, 上代码: #include using namespace std; class CA { public: CA() { cout "CA()" ; } ~CA() { cout "~CA()" ; } }; class CB : public CA { public: CB() { cout "CB()" <<
  • 1.父类构造-子类构造-子类析构-父类析构
  • class Base { public: Base() { cout父类的无参构造函数"运行结果: 总结: 构造顺序: 父类(基类)构造 ------> 子类(派生类)构造 析构顺序:子类(派生类)析构------> 父类 (基类) 析构
  • //这时候可以写一个析构,验证一下 内存回收机制 //对象树的概念,一定程度上简化了内存回收机制 //不过一定要把对象放进表里边,my->setParent(this)这个操作 //this就是MyWidget //下面打印一下MyWidget的析构 //...
  • 【C++】对象的构造和析构顺序

    千次阅读 2019-03-22 20:03:47
    文章目录程序中存在多个对象 ...程序中存在多个对象 ...调用Test成员变量(Member类)的构造函数(调用顺序与声明顺序相同:先m_A后m_B) 调用类自身的构造函数 实例代码: #include <iostream> u...
  • 问题:父类和子类的构造和析构顺序是谁先谁后? 代码如下: #include <iostream> using namespace std; //继承中的构造和析构顺序 class Base { public: Base() { cout << "Base构造函数!" <...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,157
精华内容 17,662
关键字:

析构顺序

友情链接: HB.zip