精华内容
下载资源
问答
  • 2018-03-16 22:32:26
    #include <iostream>
    #include <string>
    #include <iomanip>
    using namespace std;
    class teacher
    {
    protected:
        int sum;
        string name;
        char sex;
    public:
        void input_A()
        {
            cout<<"Please input the teacher's sum,name and sex:";
            cin>>sum;
            cin>>name;
            cin>>sex;
        }
        void output_A()
        {
            cout<<"sum:"<<sum<<"name:"<<name<<"sex:"<<sex<<endl;
        }
    };
    class birthday
    {
    public:
        int year,month,day;
            void input_B()
            {
                cout<<"Please input the teacher's birthday:(year,month,day):";
                cin>>year;
                cin>>month;
                cin>>day;
            }
            void output_B()
            {
                cout<<year<<setw(2)<<setfill('0')<<month<<setw(2)<<setfill('0')<<day<<endl;
            }
    };
    class professor:public teacher
    {
    protected:
        int sum;
        string name;
        char sex;
        birthday n;
    public:
        void update(int y,int m,int d)
        {
            n.year=y;
            n.month=m;
            n.day=d;
        }
        void input_C()
        {
            input_A();
            n.input_B();
        }
        void output_C()
        {
            output_A();
            n.output_B();
        }
        friend istream& operator >>(istream& os,professor& a)
        {
            a.input_C();
            return os;
        }
        friend ostream& operator <<(ostream& os,professor a)
        {
            a.output_C();
            return os;
        }
    };
    int main()
    {
        professor p;
        int y,d,m;
        cin>>p;
            cin>>y>>d>>m;
        p.update(y,d,m);
        cout<<p;
        return 0;
    }
    更多相关内容
  • C++继承与派生

    千次阅读 2022-04-04 14:45:37
    1.继承与派生:保持已有类的特征构造新类的过程为继承,在已有类的基础上新增特性而产生新类的过程称为派生 2.继承目的:实现代码重用;派生目的:实现源程序的改造 3.声明:class 派生类:继承方式 基类 4.派生类:...

    一.类的继承与派生:
    1.继承与派生:保持已有类的特征构造新类的过程为继承,在已有类的基础上新增特性而产生新类的过程称为派生
    2.继承目的:实现代码重用;派生目的:实现源程序的改造
    3.声明:class 派生类:继承方式 基类
    4.派生类:
    吸收基类成员:派生类包含了基类中除了构造析构函数以外的所有成员,构造析构函数不会被继承
    改造基类成员:虚函数重写(实际是虚函数表的覆盖)以及同名函数
    添加新的成员:加入新的构造析构函数以及其他成员

    二.类成员的访问:public--->protected--->private注意基类中私有成员不能被访问
    基类中的私有成员派生类无法访问
    继承方式为public时权限不变,但是私有成员也会被继承?
    继承方式为private何protected(体现类的继承特征)时,权限与继承方式一致


    三.类型兼容规则:一个公有派生类的对象在使用上可以被当成基类的对象,反之不行
    1.派生类的对象可以赋值给基类对象
    2.派生类的对象可以初始化基类的引用
    3.指向基类的指针可以指向派生类
    通过基类的对象名与指针只能使用从基类继承的成员

    #include<iostream>
    #include <string>
    using namespace std;
    class Base
    {
    public:
    	void showBase()
    	{
    		cout << "base成员函数的调用" << endl;
    	}
    };
    class Son :public Base
    {
    public:
    	void showSon()
    	{
    		cout << "Son成员函数的调用" << endl;
    	}
    };
    int main()
    {
    	Son s1;
    	Base b1 = s1;//派生类对象赋值给基类对象
    	Base& b2 = s1;//派生类对象初始化基类的引用
    	Base* b3 = &s1;//派生类地址初始化基类指针/基类指针指向派生类
    	b1.showBase();//通过基类的对象名和指针只能调用基类成员
    	b2.showBase();
    	b3->showBase();
    	return 0;
    }
    //运行结果:
    //base成员函数的调用
    //base成员函数的调用
    //base成员函数的调用
    

     


    四.单继承与多继承
    1.单继承:一个基类一个派生类
    2.多继承:多基类一派生 class 派生类:继承方式1 基类1, 继承方式2 基类2
    3.多重派生:一个基类多个派生类
    4.多层派生:派生类为基类继续派生


    五.派生类的构造与析构

    1.基类的构造析构函数不会被继承,派生类需要写自己的构造析构函数
    2.派生类的构造函数需要给基类构造函数传递参数,注意基类成员用基类名在初始化列表进行初始化!!!

    #include<iostream>
    #include <string>
    using namespace std;
    class Base
    {
    public:
    	int m_A;
    	Base(int a):m_A(a){}//如果有默认构造,派生类构造时可以不传参
    	void showBase()
    	{
    		cout << "m_A=" << m_A << endl;
    	}
    };
    class Son :public Base
    {
    public:
    	int m_B;
    	Son(int a,int b):Base(a),m_B(b){}//注意基类用基类名在初始化列表进行初始化,多个基类类推
    	void showSon()
    	{
    		cout << "m_B="<<m_B << endl;
    	}
    };
    int main()
    {
    	Son s(10, 20);
    	s.showBase();
    	s.showSon();
    	return 0;
    }
    //运行结果:
    //m_A = 10
    //m_B = 20


    六.类成员的标识与访问

    1.当派生类与基类成员同名时,优先调用派生类成员,基类同名成员被屏蔽(包括重载)
    2.通过作用域来访问

    #include<iostream>
    #include <string>
    using namespace std;
    class Base
    {
    public:
    	int m_A;
    	Base(int a):m_A(a){}
    	void show()
    	{
    		cout << "基类m_A=" << m_A << endl;
    	}
    	void show(int a)
    	{
    		cout << "基类重载" << endl;
    	}
    };
    class Son :public Base
    {
    public:
    	int m_A;
    	Son(int a1,int a2):Base(a1),m_A(a2){}
    	void show()
    	{
    		cout << "派生类m_B="<<m_A << endl;
    	}
    };
    int main()
    {
    	Son s(10, 20);
    	s.show();//默认派生类,屏蔽了基类同名成员,包括重载
    	s.Base::show();//作用域访问基类
    	s.Base::show(10);//作用域访问基类重载类型
    	return 0;
    }
    //运行结果:
    //派生类m_B = 20
    //基类m_A = 10
    //基类重载
    

    3.菱形继承引发的二义性问题:B1,B2继承A,C继承B1和B2,解决方法:同名屏蔽或虚函数

    A类称为虚基类,在继承前加virtual,vbptr虚基类指针virtual base pointer指向虚基数表

    #include <iostream>
    using namespace std;
    class BaseA
    {
    public:
    	int m_A;
    	BaseA(int a):m_A(a){}
    };
    class BaseB1 :virtual public BaseA//虚继承
    {
    public:
    	int m_B1;
    	BaseB1(int a,int b1):BaseA(a),m_B1(b1){}
    };
    class BaseB2 :virtual public BaseA//虚继承
    {
    public:
    	int m_B2;
    	BaseB2(int a,int b2):BaseA(a),m_B2(b2){}
    };
    class SonC :public BaseB1, public BaseB2
    {
    public:
    	int m_C;
    	SonC(int a,int b1,int b2,int c):BaseA(a),BaseB1(a,b1),BaseB2(a,b2),m_C(c){}
    };
    int main()
    {
    	SonC c(30,20,20,30);//B1,B2也可以初始化虚基类,但是C直接初始化优先级更高,调用了一次
    	cout << c.m_A << endl;
    	return 0;
    }
    //运行结果:30
    /*
    class BaseB1    size(12):
    		+---
     0      | {vbptr}
     4      | m_B1
    		+---
    		+--- (virtual base BaseA)
     8      | m_A
    		+---
    
    BaseB1::$vbtable@:
     0      | 0
     1      | 8 (BaseB1d(BaseB1+0)BaseA)
    vbi:       class  offset o.vbptr  o.vbte fVtorDisp
    		   BaseA       8       0       4 0
    */
    
    /*
    class SonC      size(24):
    		+---
     0      | +--- (base class BaseB1)
     0      | | {vbptr}
     4      | | m_B1
    		| +---
     8      | +--- (base class BaseB2)
     8      | | {vbptr}
    12      | | m_B2
    		| +---
    16      | m_C
    		+---
    		+--- (virtual base BaseA)
    20      | m_A
    		+---
    
    SonC::$vbtable@BaseB1@:
     0      | 0
     1      | 20 (SonCd(BaseB1+0)BaseA)
    
    SonC::$vbtable@BaseB2@:
     0      | 0
     1      | 12 (SonCd(BaseB2+0)BaseA)
    vbi:       class  offset o.vbptr  o.vbte fVtorDisp
    		   BaseA      20       0       4 0
    */
    

    建立对象所指定的类称为最(远)派生类
    虚基类的成员由最派生类调用虚基类的构造函数进行初始化,在初始化列表调用构造函数初始化。

    虚函数与纯虚函数在多态进行总结

     

     

    展开全文
  • 继承与派生 1.派生类定义: class 派生类名:继承方式 基类名 { 派生类成员声明 //派生类新增的数据成员和成员函数 }; 2.派生类生成过程: (1 继承除基类的构造函数和析构函数之外的所有数据成员和...

                     继承与派生

    1.派生类定义:

                   class 派生类名:继承方式 基类名

                   {

                      派生类成员声明

                          //派生类新增的数据成员和成员函数

                   };

    2.派生类生成过程:

               (1 继承除基类的构造函数和析构函数之外的所有数据成员和成员函数。

               (2 对基类成员改造:1.依靠派生类的继承方式控制派生类类内和类外对基类成员的访问  2.对基类数据成员覆盖或对基类成员函数重新定义。

               (3 增加新的成员

    3.

    4.派生类构造函数:

               派生类构造函数(参数表):参数化表

               {

                   派生类新增成员的初始化语句

               }

    5.派生类构造函数名与派生类名相同;

      

    6.派生类对象构造函数执行顺序:

              基类的构造函数

              参数化中部分列出的对象成员的构造函数

              派生类构造函数的函数体

              先祖先(基类),再客人(对象成员),后自己(派生类本身)

    7.派生类的析构函数:

              先自己(派生类本身),再客人(对象成员),后祖先(基类)

    8.单重继承: 派生类只有一个直接基类

      多重继承: 派生类有多个直接基类

    多重继承的定义:

    9.在某些情况下,由于派生类继承了多个基类的全部成员,会出现派生类中数据成员或成员函数重名现象,导致派生类出现引用同名成员的二义性困惑。

      (1 从不同基类继承的同名成员,引用时产生二义性

      (2 低层派生类从不同路径多次继承同一个基类,产生二义性。

    10.虚基类:

          当基类派生出新类时,使用virtual将基类说明成虚基类。

    展开全文
  • 第九章继承派生类 92 典型例题分析解答 例题 1下列对派生类的...答案D 分析一个派生类可以作为另一个派生类的基类无论是单继承还是多继承派生类至少有 一个基类派生类的成员除了它自己的成员外还包含了它的基类成员
  • C++继承与派生.doc

    2021-08-17 11:11:13
    (1)定义一个Person类, 包含...(2)从Person类以public方式派生Student类,具有学号、成绩等基本信息。 (3)从Person类以protected方式派生Teacher类,具有职称、工资等信息。 (4)分别设计各派生类中的构造、析构函数。
  • c++继承与派生习题答案
  • 本资源是C++继承与派生类实验报告,欢迎大家下载阿!
  • c++继承与派生习题答案.doc
  • C++ 继承与派生

    千次阅读 2018-08-15 22:50:09
    •低层(派生类):比它的上一层更具体,并且含有高层的特性(继承),同时也高层有细微的不同 •继承性是程序设计中一个非常有用的、有力的特性,它可以让程序员在既有类的基础上,通过增加少量代码或修改少量...

    为什么要使用继承:
    •最高层(基类):是最普遍、最一般的
    •低层(派生类):比它的上一层更具体,并且含有高层的特性(继承),同时也与高层有细微的不同
    •继承性是程序设计中一个非常有用的、有力的特性,它可以让程序员在既有类的基础上,通过增加少量代码或修改少量代码的方法得到新的类,从而较好地解决了代码重用的问题

    一般格式:

    class 派生类名:派生方式基类名{
        //派生类新增的数据成员和成员函数
    };

    派生分类:
    ?在声明派生类时,根据“派生方式”所写的关键字不同可以分为三种派生方式:?用public关键字的为公有派生方式?用private关键字的为私有派生方式?用protected关键字的为保护派生方式
    ?从继承源上分:?单继承:指每个派生类只直接继承了一个基类的特征?多继承:指多个基类派生出一个派生类的继承关系,多继承的派生类直接继承了不止一个基类的特征

    class employee:publicperson{
    //…
    };
    •基类中的私有成员–>派生类中不可访问
    •基类中的公有成员–>派生类中是公有的

    //公有派生
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class Base{     //基类
    private:
        int x;
    public:
        int y;
        void setXY(int n,int m){
            x = n;
            y = m;
        }
        void showXY(){
            cout<<x<<','<<y<<endl;
        }
    };
    
    class Derived:public Base{      //公有派生类
    private:
        int z;
    public:
        void setZ(int m){ 
            z = m;
        }
        /*void show(){
            cout<<x<<','<<y<<','<<z<<endl;
        }*/
    };
    
    
    int main()
    {
        Derived obj;
        obj.y = 3;
        obj.setXY(10,20);       //ok
        obj.setZ(30);           //ok
        obj.showXY();           //ok
        //obj.show();               //okx
        return 0;
    }

    ?私有派生
    class employee:privateperson{
    //…
    };

    •基类中的私有成员–>派生类中不能访问
    •基类中的公有成员–>派生类中是私有的

    //私有继承
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class base{     //基类
    private:
        int x;
        int y;
    public:
        void setXY(int n,int m){
            x = n;
            y = m;
        }
        void showXY(){
            cout<<x<<','<<y<<endl;
        }
    };
    
    class derived:private base{     //私有派生类
    private:
        int z;
    public:
        void set(int n,int m,int r){  
            setXY(n,m);
            z = r;
        }
        void show(){ 
            cout<<z<<endl;
            showXY();
            //cout<<x<<','<<y<<','<<z<<endl;        //?
        }
    };
    
    int main()
    {
        derived obj;
    //  obj.setXY(10,20);                       //?
        obj.set(10,20,30);
        obj.show();
        return 0;
    }

    ?私有成员在派生类中是无权直接访问的,只能通过调用基类中的公有成员函数的方式实现
    ?一定要直接访问基类中的私有成员,可以把这些成员声明为保护成员rotected。一般格式:

    class 类名{
        private:
            私有成员
        protected:
            保护成员
        public:
            公有成员
    };
    //不涉及派生时,保护成员与私有成员的地位完全一致。
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class Samp{
    private:
        int a;
    protected:  
        int b;
    public: 
        int c;
        Samp(int n,int m){
            a = n;
            b = m;
        }
        int getA(){
            return a;
        }
        int getB(){
            return b;
        }
    };
    
    int main()
    {   
        Samp obj(20,30);
        //obj.a = 11;       //Error,私有成员
        //obj.b = 22;       //Error,保护成员
        obj.c = 33;     //Ok
        cout<<obj.getA()<<' '<<obj.getB()<<endl;    //Ok
        return 0;
    }
    //基类中的保护成员在公有派生的派生类中仍是保护的
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class Base{
    protected:
        int a, b;
    public:
        void setAB(int n,int m){
            a = n;
            b = m;
        }
    };
    
    class Derive:public Base{
    private:
        int c;
    public: 
        void setC(int n){
            c = n;
        }
        void showABC(){
            cout<<a<<' '<<b<<' '<<c<<endl; 
        }
    };
    
    int main()
    {   
        Derive obj;
        //obj.a = 3;
        obj.setAB(2,4);
        obj.setC(3);
        obj.showABC();
        return 0;
    }
    //构造函数与析构函数的执行顺序
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class Base{
    protected:
        int a;
    public:
        void setA(int sa){
            a = sa;
        }
    };
    
    
    class Derive1:private Base{
    protected:
        int b;
    public:
        void setB(int sb){
            b = sb;
        }
    };
    
    class Derive2:public Derive1{
    private:
        int c;
    public:
        void setC(int sc){
            c = sc;
        }
        void show(){
            cout<<a<<' '<<b<<' '<<c<<endl;
            //cout<<b<<' '<<c<<endl;
        }
    };
    
    int main()
    {
        Base op1;
        op1.setA(1);
    
        Derive1 op2;
        op2.setB(2);
    
        Derive2 op3;
        op3.setC(3);
        op3.setB(4);
    
        op3.show();
        return 0;
    }

    •基类中的私有成员–>派生类中不能访问
    •基类中的公有成员–>派生类中是保护的保护派生

    class employee:protectedperson{
        //…
    };
    //保护派生
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class Base{     //基类
    private:
        int x;
    public:
        int y;
        void setXY(int n,int m){
            x = n;
            y = m;
        }
        void showXY(){
            cout<<x<<','<<y<<endl;
        }
    };
    
    class Derived:protected Base{       //保护派生类
    private:
        int z;
    public:
        void setXYZ(int a,int b,int m){ 
            setXY(a,b);
            z = m;
        }
        void show(){
            showXY();
            cout<<z<<endl;
        }
    };
    
    int main()
    {
        Derived obj;
        //obj.y = 3;            //error
        //obj.setXY(10,20);     //error
        obj.setXYZ(10,20,30);           //ok
    //  obj.showXY();           //error
        obj.show();             //okx
        return 0;
    }

    这里写图片描述

    ��多继承可以看作是单继承的扩展。所谓多继承是指派生类具有多个基类,派生类与每个基类之间的关系仍可看作是一个单继承。
    ��多继承下派生类的定义格式如下:

    class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…{
        <派生类类体>
    };

    其中,<继承方式1>,<继承方式2>,…是三种继承方式:public、private、protected之一
    注意:当使用多继承时要注意避免发生二义性

    class A{
        public:
        //……
    };
    class B{
        public:
        //……
    };
    class C:publicA,publicB{
        ……
    };
    在定义如下时:
    C c1;
    c1.print(); //error

    解决方法是:c1.A::print();//调用A的或者c1.B::print();//调用B的..在C公有继承A和B,当A和B都公有继承D时,这使得A和B都具有D的公有部分,在C中使用D的公有部分时,编译器就会不确定是调用A的还是调用B的而出现错误

    1 派生类构造函数和析构函数的执行顺序
    ..派生类构造函数的执行顺序:
    基类构造函数 —–> 派生类构造函数
    ..派生类析构函数的执行顺序:
    派生类构造函数 —–> 基类构造函数

    //派生类的构造函数与析构函数的执行顺序
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class Base{
    public:
        Base(){
            cout<<"Construction base class.\n";//1
        }
        ~Base(){
            cout<<"Destruction base class.\n";//4
        }
    };
    
    class Derive:public Base{
    public:
        Derive(){
            cout<<"Construction derived class.\n";//2
        }
        ~Derive(){
            cout<<"Destruction derived class.\n";//3
        }
    };
    
    int main()
    {
        Derive op;
        return 0;
    }

    ��当基类的构造函数没有参数(或全部默认值),或没有显示定义构造函数时,那么派生类可以不向基类传递参数,可以不定义构造函数
    ��当基类含有带参数的构造函数时,派生类必须定义构造函数,以提供把参数传递给基类构造函数的途径
    •派生类构造函数的一般格式:
    派生类构造函数名(参数表0):基类构造函数名(参数表1){
    //…
    }

    •当派生类中含有对象成员时,其构造函数的一般形式为:
    派生类构造函数名(参数表0):基类构造函数名(参数表1),对象成员名1(参数表2),…,对象成员名n(参数表n+1){
    //…
    }
    在定义派生类对象时,构造函数与析构函数的执行顺序为:
    ..派生类构造函数的执行顺序:
    基类构造函数 —–>对象成员 —–> 派生类构造函数
    ..派生类析构函数的执行顺序:
    派生类构造函数 —–> 对象成员 —–> 基类构造函数

    //构造函数与析构函数的执行顺序
    #include <iostream>
    
    using std::cin;
    using std::cout;
    using std::endl;
    
    class Base{
    private:
        int x;
    public:
        Base(int i){ 
            x = i;
            cout<<"构造base类, x="<<x<<endl;
        }
        ~Base(){ 
            cout<<"析构base类, x="<<x<<endl;
        }
        void show(){ 
            cout<<"x="<<x<<endl;
        }
    };
    
    
    class Derive:public Base{
    private:
        int y;
        Base d;
    public:
        Derive(int i,int j,int k):Base(i),d(j){ 
            y = k;
            cout<<"构造derived类, y="<<y<<endl;
        }
        ~Derive(){ 
            cout<<"析构derived类, y="<<y<<endl;
        }
    };
    
    int main()
    {
        Derive obj(1,2,3);
        obj.show();
        return 0;
    }

    输出结果:
    构造base类,x=1
    构造base类,x=2
    构造derived类,y=3
    x=1
    析构derived类,y=3
    析构base类,x=2
    析构base类,x=1

    说明
    :•如果派生类的基类也是一个派生类,则每个派生类只需负责其直接基类的构造,依次上溯
    •由于析构函数是不带参数的,在派生类中是否要定义析构函数与它所属的基类无关,故基类的析构函数不会因为派生类没有析构函数而得不到执行,它们各自是独立的

    展开全文
  • c++继承与派生

    2013-01-19 20:57:51
    c++继承与派生,上机操作题,帮助理解继承与派生
  • C++继承与派生虚基类[参照].pdf
  • C++继承派生

    2019-01-17 16:15:55
    信息科学技术学院《程序设计实习》,C++程序员入门级教程
  • 主要介绍了 C++ 类的继承与派生实例详解的相关资料,需要的朋友可以参考下
  • C++继承与派生ppt

    2011-11-19 16:38:32
    很不错的C++课件,简单易懂,适合自学。深入浅出指点到位
  • 1、C++继承的概念及语法 继承是类类之间的关系,是一个很简单很直观的概念,现实世界中的继承类似,例如儿子继承父亲的财产。 继承(Inheritance) 可以理解为一个类从另一个类获取成员变量和成员函数的过程...
  • c++课程基础! 继承与派生! 想往c++方面发展的可以看一下!
  • C++继承与派生PPT

    2015-08-31 17:11:10
    C++课程资源,详细介绍C++继承与派生规则和使用情况
  • C++ 上课/复习ppt继承与派生.ppt
  • c++ 继承与派生

    2012-12-13 10:43:32
    很有用
  • 某软件公司资深讲师的详细课件,不传外的,好不容易拿了章,继承多态机制的深入解析。
  • C++继承与派生课件

    2010-05-20 16:11:57
    C++继承与派生课件 很值得下载 C++继承与派生课件 很值得下载
  • c++继承与派生

    2021-05-11 17:45:20
    本篇文章主要讲的就是c++继承的相关知识点。 一、继承与派生的概念 面向对象技术强调软件的可重用性,c++的可重用性就是通过继承来实现的。一个新类从已有的类哪里获得其已有的特性,这种现象称为类的继承。从另外一...
  • c++程序设计 继承与派生实验(二) 1. 进一步掌握类的派生与继承的概念、应用方法 2. 掌握继承方式对成员访问权限的影响 3. 掌握虚基类的用法
  • C++ 继承与派生编程题

    千次阅读 2020-03-25 15:00:42
    C++ 继承与派生—笔记 1. 编写一个程序,其中有一个汽车类Vehicle,它具有一个需要传递参数的构造函数,类中的数据成员:车轮个数wheels和车重weight为保护属性;小车类Car是它的私有派生类,其中包含载人数passager...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 100,961
精华内容 40,384
关键字:

c++继承与派生

c++ 订阅
友情链接: VCPP-management-system.zip