精华内容
下载资源
问答
  • 1.父类构造-子类构造-子类析构-父类析构

    1.父类构造-子类构造-子类析构-父类析构

    展开全文
  • 继承方式 ...注意:父类中的私有成员子类以任意方式继承都不能访问 例: # include<iostream> using namespace std; //父类 class Base { public: int m_a; protected: int m_b; privat...

    继承方式

    1、公共继承(public)
    2、保护继承(protected)
    3、私有继承(private)
    注意:父类中的私有成员子类以任意方式继承都不能访问
    例:

    # include<iostream>
    using namespace std;
    
    //父类
    class Base
    {
    public:
        int m_a;
    protected:
        int m_b;
    private:
        int m_c;
    };
    
    //以public方式继承的子类
    class Base_son :public Base
    {
    public:
        void func()
        {
            m_a = 10;//父类中的公共成员 到子类中依然是公共成员
            m_b = 10;//父类中的保护成员 到子类中依然是保护成员
        }
    };
    
    //以protected方式继承的子类
    class Base_son1 :protected Base
    {
    public:
           void func()
           {
               m_a = 100;//父类中公有成员,到子类变为保护成员
               m_b = 100;//父类中保护成员,子类依旧是保护成员
           }
    };
    
    //以private方式继承的子类
    class Base_son2 :private Base
    {
    public:
        void func()
        {
            m_a = 100; //父类中公有,到子类变为私有
            m_b = 100; //父类中保护,到子类变为私有
        }
    
    };
    
    

    总结:
    以public方式继承:父类的公有成员和保护成员到子类对应也是公有和保护成员
    以protected方式继承:父类中的公有和保护成员到子类都为保护成员
    以private方式继承:父类中的公有和保护成员到子类都为私有成员

    继承的资源

    父类中所有非静态的成员都会被子类继承,包括私有成员也会被继承,只是子类无法访问
    验证:

    # include<iostream>
    using namespace std;
    
    class Based
    {
    public:
        int m_a;
    protected:
        int m_b;
    private:
        int m_c;
    };
    
    class based_son :public Based
    {
    public:
        int m_d;
    };
    
    void example()
    {
      cout<<"sizeof son = "<< sizeof(based_son) << endl;
    }
    
    int main()
    {
       example();
       return 0;
    }
    

    输出结果:
    在这里插入图片描述

    父类和子类构造和析构顺序

    # include<iostream>
    using namespace std;
    
    //父类
    class Based
    {
    public:
         Based()
         {
             cout << "Based的构造函数" << endl;
         }
         ~Based()
         {
             cout << "Based的析构函数" << endl;
         }
    };
    
    //子类
    class Based_son :public Based
    {
    public:
         Based_son ()
         {
             cout << "Based_son 的构造函数" << endl;
         }
         ~Based_son ()
         {
             cout << "Based_son 的析构函数" << endl;
         }
    };
    
    void example()
    {
       Based_son s1;
    }
    
    int main()
    {
       example();
       return 0;
    }
    

    输出结果:
    在这里插入图片描述
    可以看见,子类会先调用父类的构造函数,然后再调用自身的构造函数,
    然后调用自身析构函数,最后再调用父类的析构函数

    展开全文
  • 构造方法用来初始化类的对象,与父类的其它成员不同,它不能被子类继承(子类可以继承父类所有的成员变量成员方法,但不继承父类的构造方法)。因此,在创建子类对象时,为了初始化从父类继承来的数据成员,系统...

    构造方法用来初始化类的对象,与父类的其它成员不同,它不能被子类继承(子类可以继承父类所有的成员变量和成员方法,但不继承父类的构造方法)。因此,在创建子类对象时,为了初始化从父类继承来的数据成员,系统需要调用其父类的构造方法。

    如果没有显式的构造函数,编译器会给一个默认的构造函数,并且该默认的构造函数仅仅在没有显式地声明构造函数情况下创建。

    构造原则如下:

        1. 如果子类没有定义构造方法,则调用父类的无参数的构造方法。

        2. 如果子类定义了构造方法,不论是无参数还是带参数,在创建子类的对象的时候,首先执行父类无参数的构造方法,然后执行自己的构造方法。

        3. 在创建子类对象时候,如果子类的构造函数没有显示调用父类的构造函数,则会调用父类的默认无参构造函数。

        4. 在创建子类对象时候,如果子类的构造函数没有显示调用父类的构造函数且父类自己提供了无参构造函数,则会调用父类自己的无参构造函数。

        5. 在创建子类对象时候,如果子类的构造函数没有显示调用父类的构造函数且父类只定义了自己的有参构造函数,则会出错(如果父类只有有参数的构造方法,则子类必须显示调用此带参构造方法)。

        6. 如果子类调用父类带参数的构造方法,需要用初始化父类成员对象的方式,比如:

    #include <iostream.h>  
     class animal  
     {  
     public:  
       animal(int height, int weight)  
       {  
         cout<<"animal construct"<<endl;  
       }  
       …  
     };  
     class fish:public animal  
     {  
     public:  
       fish():animal(400,300)  
       {  
         cout<<"fish construct"<<endl;  
       }  
       …  
     };  
     void main()  
     {  
       fish fh;  
     }  
    fish 类的构造函数后,加一个冒号( : ),然后加上父类的带参数的构造函数。这样,在子类的构造函数被调用时,系统就会去调用父类的带参数的构造函数去构造对象。

    展开全文
  • 父类的构造和析构 对象成员的构造和析构 子类自身的构造和析构 总结:(重要) class Other { public: Other() { cout<<"对象成员的构造函数"<<endl; } ~Other() { cout<<"对象成员的...

    父类的构造和析构 对象成员的构造和析构 子类自身的构造和析构

    总结:(重要)

    class Other
    {
    public:
        Other()
        {
            cout<<"对象成员的构造函数"<<endl;
        }
        ~Other()
        {
            cout<<"对象成员的析构函数"<<endl;
        }
    };
    class Base
    {
    public:
        Base()
        {
            cout<<"父类的无参构造函数"<<endl;
        }
        ~Base()
        {
            cout<<"父类中的析构函数"<<endl;
        }
    };
    class Son:public Base
    {
    public:
        Son()
        {
            cout<<"子类的无参构造"<<endl;
        }
        ~Son()
        {
            cout<<"子类中的析构函数"<<endl;
        }
    
        Other ob;//对象成员
    
    };
    void test01()
    {
        Son ob1;
    }

    运行结果:

     

    展开全文
  • //父类子类 析构与构造的调用顺序 class Animal { public: Animal() { cout << "animal construct" << endl; } ~Animal() { cout << "animal destruct" << endl; } v...
  • 对象析构时与构造顺序相反,子类先调用自身的析构函数,再调用子类成员变量的析构函数,再调用父类的析构函数,再析构父类的成员变量。 测试代码如下: #include using namespace std; cl
  • 在C++中,当子类继承了父类的时候,你创建一个子类对象,会先创建父类这个对象,调用父类的构造函数,然后调用子类的构造,如果你删除子类对象的时候,会先调用子类析构,最后调用父类的析构函数。 #include<...
  • 子类父类构造函数调用顺序 构造函数 当创建子类对象时, 构造...子类的析构函数的调用顺序和子类的构造函数的调用顺序相反!!! 记住,相反即可。 #include <iostream> #include <Windows.h> usi
  • 子类析构时是否要调用父类的析构函数

    千次阅读 多人点赞 2019-03-21 17:18:23
    构造时,先构造父类,再构造子类部分,因此父类和子类的构造函数都会被调用; 析构时,要分情况: (1)(父类析构函数不是虚函数)使用父类指针指向子类对象,析构子类对象时,只会调用父类析构函数,因为不具...
  • 1、子类被构造的时候会先调用父类的构造函数 ...2、子类析构的时候先析构子类析构父类 3、如果直接用子类构造一个父类的对象,删除这个父类的对象不会调用子类的析构函数,这就是引入虚析构函数的原因!...
  • #include using namespace std; class a{ public: a(){ cout; } ~a(){ cout; } }; class b:public a{ ...父构造->子构造->子析构->父构造 好像一个栈
  • 2018-03-19 创建人:Ruo_Xiao 邮箱:xclsoftware@163.com 建立对象时,会先调用父类的构造函数再调用子类的构造函数。 销毁对象时,会先调用子类的析构函数再调用父类的析构函数 ...
  • 子类构造和析构被执行时是否调用父类以及调用顺序 子类被构造的时候回先调用父类的构造函数 子类析构的 时候先析构子类析构父类 如果直接用子类构造一个父类的对象,删除这个父类的对象不会调用子类的析...
  • 析构函数调用的次序是先派生类的析构后基类的析构,也就是说在基类的的析构调用的时候,派生类的信息已经全部销毁了。 而定义一个对象时先调用基类的构造函数、然后调用派生类的构造函数;析构的时候恰好相反:先...
  • 还有一种情况是是析构函数是虚函数,结果是:析构函数调用子类-》父类,不过内部原理不一样 delete a时调用类型A的析构函数步骤如下: 1,到虚函数映射表中查找A的实际析构函数; 2,发现被实例化为B的析构函数...
  • 2.继承中先调用父类构造函数,再调用子类构造函数,析构顺序与构造相反 #include<iostream> using namespace std; #include<string> //继承中的构造和析构顺序 class Base { public: Base() { ...
  • 探讨这一块的内容,理论就不在叙述了,以例子进行说明: 代码: ngnsvr9 [** NONE **]/...执行顺序父类的构造函数 子类的构造函数 子类的析构函数 父类的析构函数   希望对大家有所帮助!  
  • C++父类子类间构造,析构,拷贝的调用关系 构造 子类的构造在执行它的构造函数前会根据继承表的顺序执行父类的构造函数 默认执行无参构造 #include <iostream> #include <stdio.h> #include <...
  • cout析构基类"; } protected: char *name; }; class student:public person { public: char *address; student(char *s):person(s) { address=new char[strlen(s)+1];strcpy(address,s); cout...
  • C++ 类成员的构造和析构顺序

    千次阅读 2018-07-18 11:46:00
    我想对面向对象有了解的童鞋应该不会对类对象感到陌生吧 ! 对象并不是突然建立起来的,创建对象必须时必须同时创建父类以及包含于其中的对象。C++遵循如下的创建顺序: (1)如果某个类具体基类,执行基类的默认...
  • 假如有一个父类A(基类),一个的子类B,公有继承于A,当在测试文件(main函数)里,定义一个子类对象d,d对象的初始化会调用d的构造函数,但d对象的构造函数要想完成初始化必须先初始化父类的,因为子类B继承于A,A...
  • Python中父类子类与继承的关系

    千次阅读 2021-01-14 20:01:23
    原标题:父类子类与继承的关系先有父类,再有...析构函数调用的先后顺序与构造函数相反继承的概念:面向对象中的继承指类之间的父子关系,子类拥有父类的某些状态行为,(子类复用了父类的功能或状态)。继承有三...
  • class Base { public: Base() { cout<<"父类的无参构造函数"<<endl; } ~Base() { cout<<"父类中的析构函数"<<endl; } }; class Son:public Base ..."子类的无参构造"<<endl; .
  • 构造函数: 父类的先执行,子类的后执行 析构函数: 父类的后执行,子类的先执行   T1.h //父类 #ifndef k //防止头文件重复包含的问题 #define k #include using namespace std; class T1 { public: T1() ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,442
精华内容 4,576
关键字:

子类和父类的析构顺序