精华内容
下载资源
问答
  • c++类的继承与派生
    千次阅读
    2022-04-04 14:45:37

    一.类的继承与派生:
    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
    */
    

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

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

     

     

    更多相关内容
  • C++ 继承与派生实例详解 继承性是面向对象程序设计最重要的特性之一,使软件有了可重用性,C++提供的继承机制。 继承与派生的概念 一个新从已有的那里获得已有的特性,这种现象称为继承。同样也可以...
  • 第九章继承派生 92 典型例题分析解答 例题 1下列对派生的...答案D 分析一个派生可以作为另一个派生的基类无论是单继承还是多继承派生类至少有 一个基类派生的成员除了它自己的成员外还包含了它的基类成员
  • 实验四 C++中的继承与派生 一实验目的 理解C++继承与派生的概念 掌握C++中各种不同继承方式的访问属性差别 掌握单继承与继承的实现方法 掌握派生类构造函数析构函数的实现及调用顺序 掌握虚基类的使用方法 二...
  • C++复习3 ----继承与派生 为什么要继承 如果软件编写的工程规模很大重用已经测试过的代码要比重新编写新代码节省开发时间 基类与派生类 从已经定义的产生新的过程称为派生派生过程中已定义的称为基类...
  • C++实验继承与派生

    千次阅读 2020-11-07 12:42:24
    2. 理解类的访问控制与类的成员访问的关系。 3. 熟悉不同继承方式下对基类成员的访问控制。 4. 学习利用虚基类解决二义性问题。 二、实验环境: Visual C++ 三、实验内容: (写出主要的内容) 1. 定义一个基类...

    桂 林 理 工 大 学
    实 验 报 告
    实验名称 继承与派生 日期 2019年 05 月05 日
    一、实验目的:
    1. 学习定义和使用类的继承关系,定义派生类。
    2. 理解类的访问控制与类的成员访问的关系。
    3. 熟悉不同继承方式下对基类成员的访问控制。
    4. 学习利用虚基类解决二义性问题。
    二、实验环境:
    Visual C++

    三、实验内容:
    (写出主要的内容)
    1. 定义一个基类Animal,有私有整形成员变量age,构造其派生类dog,在其成员函数SetAge(int n)中直接给age赋值,看看会有什么问题,把age改为公有成员变量,还会有问题吗?改为保护类型呢?改变继承方式呢?

    #include<iostream>
    using namespace std;
    class Animal
    {
    	protected:
    		int age;
    	public:
    		Animal();
    		~Animal();
    };
    Animal::Animal()
    {
    	cout<<"构造了一个Animal!"<<endl;
    }
    Animal::~Animal()
    {
    	cout<<"析构了一个Animal!"<<endl;
     }
    class Dog:public Animal
    {
    	public:
    	Dog();
    	~Dog();
    	void SetAge(int n);	
     };
    Dog::Dog()
    {
    	cout<<"构造了一个Dog!"<<endl;	
     } 
    Dog::~Dog() 
    {
    	cout<<"析构了一个Dog!"<<endl;
    }
    void Dog::SetAge(int n)
    {
    	age=n;
    	cout<<"The Dog's age:"<<n<<endl;
     }
    int main()
    {
    	Dog a;
    	a.SetAge(5); 
     }
    

    输出结果:构造了一个Animal!
    构造了一个Dog!
    The Dog’s age:5
    析构了一个Dog!
    析构了一个Animal!
    2. 通过在上例的构成函数、析构函数中添加提示信息,或用debug调试功能观察构造函数和析构函数的执行情况,并分析原因。

     #include<iostream>
    using namespace std;
    class Animal
    {
    	protected:
    		int age;
    	public:
    		Animal();
    		~Animal();
    };
    Animal::Animal()
    {
    	cout<<"构造了一个Animal!"<<endl;
    }
    Animal::~Animal()
    {
    	cout<<"析构了一个Animal!"<<endl;
     }
    class Dog:public Animal
    {
    	public:
    	Dog();
    	~Dog();
    	int SetAge();
    	void PutAge();	
     };
    Dog::Dog()
    {
    	cout<<"构造了一个Dog!"<<endl;	
     } 
    Dog::~Dog() 
    {
    	cout<<"析构了一个Dog!"<<endl;
    }
    int Dog::SetAge()
    {
    	int n;
    	cout<<"Please input the Dog's age:";
    	cin>>n;
    	age=n;	
    	return age;
     }
     void Dog::PutAge()
     {
     	cout<<"The Dog's age:"<<age<<endl;
     }
    int main()
    {
    	Dog a;
    	a.SetAge();
    	a.PutAge(); 
     }
    

    输出结果:构造了一个Animal!
    构造了一个Dog!
    Please input the Dog’s age:6
    The Dog’s age:6
    析构了一个Dog!
    析构了一个Animal!
    3. 定义一个车(vehicle)基类,具有MaxSpeed、Weight等成员变量,Run、Stop等成员函数,由此派生出自行车(bicycl)类、汽车(motorcar)类。自行车类有高度(Height)等属性,汽车类有座位数(SeatNum)等属性。从和派生出摩托车(motorcycle)类,在继承过程中注意把设置为虚基类。如果不把vehice设置为虚基类,会有什么问题?并分析原因。
    Motorcycle无法运行,因为产生了二义性

     #include<iostream>
    using namespace std;
    class Vehicle
    {
    private:
    	int MaxSpeed;
    	int Weigth;
    public:
    	Vehicle();
    	~Vehicle();
    	void Run();
    	void Stop();
    		
    };
    Vehicle::Vehicle()
    {
    	MaxSpeed=0;
    	Weigth=0;
    	cout<<"构造了一个Vehicle"<<endl;	
    }
    Vehicle::~Vehicle()
    {
    	cout<<"析构了一个Vehicle"<<endl;
    }
    void Vehicle::Run()
    {
    	cout<<"Vehicle开始运行!"<<endl;
    }
    void Vehicle::Stop()
    {
    	cout<<"Vehicle停止运行!"<<endl;
    }
    
    class bicycle:virtual public Vehicle
    {
    private:
    	int Height;
    public:
    	bicycle();
    	~bicycle();	
    };
    bicycle::bicycle()
    {
    	cout<<"构造了一个bicycle"<<endl;	
    }
    bicycle::~bicycle()
    {
    	cout<<"析构了一个bicycle"<<endl;
    }
    
    class motocar:virtual public Vehicle
    {
    private:
    	int SetNumber;
    public:
    	motocar();
    	~motocar();
    	 
    };
    motocar::motocar()
    {
    	cout<<"构造了一个motocar"<<endl;	
    }
    motocar::~motocar()
    {
    	cout<<"析构了一个motocar"<<endl;
    }
    
    class motorcycle:public bicycle,public motocar
    {
    public:
    	motorcycle();
    	~motorcycle();	
    };
    motorcycle::motorcycle()
    {
    	cout<<"构造了一个motorcycle"<<endl;
    }
    motorcycle::~motorcycle()
    {
    	cout<<"析构了一个motorcycle"<<endl;
    }  
    
    int main()
    {
    	Vehicle a;
    	bicycle b;
    	motocar c;
    	motorcycle d;
    	a.Run() ;
    	a.Stop() ;
    	b.Run() ;
    	b.Stop() ;
    	c.Run() ;
    	c.Stop() ;
    	d.Run() ;
    	d.Stop() ;	
    }
    

    输出结果:
    构造了一个Vehicle
    构造了一个Vehicle
    构造了一个bicycle
    构造了一个Vehicle
    构造了一个motocar
    构造了一个Vehicle
    构造了一个bicycle
    构造了一个motocar
    构造了一个motorcycle
    Vehicle开始运行!
    Vehicle停止运行!
    Vehicle开始运行!
    Vehicle停止运行!
    Vehicle开始运行!
    Vehicle停止运行!
    Vehicle开始运行!
    Vehicle停止运行!
    析构了一个motorcycle
    析构了一个motocar
    析构了一个bicycle
    析构了一个Vehicle
    析构了一个motocar
    析构了一个Vehicle
    析构了一个bicycle
    析构了一个Vehicle
    析构了一个Vehicle
    四、 心得体会:
    1、学会了如何定义和使用类的继承关系,定义派生类。
    2、理解了类的访问控制与类的成员访问的关系。
    3、熟悉了不同继承方式下对基类成员的访问控制。
    4、学会了如何利用虚基类解决二义性问题。

    展开全文
  • 本资源是C++继承与派生类实验报告,欢迎大家下载阿!
  • 1、单继承:class 派生类名:访问方式 基类名{ 派生类成员} 说明: 1.派生类名由用户自己命名 2.访问方式:公有、私有、保护 3.基类名必须是程序一个已有的 4.冒号:告诉系统,派生类从那个基类派生 5.派生类...
  • 的组成结构和功能,实用,功能性强,水平高,完成的程序编程
  • C++ 上课/复习ppt继承与派生.ppt
  • Circle从shape类继承,并派生以下成员 1)私有成员r 2)公有getter和setter 3)计算面积函数getArea(),返回计算面积; 4)构造析构函数 Rectangle从shape类继承,并派生以下成员 1)私有成员h,w 2)公有getter...
  • 继承与派生 1.派生类定义: class 派生类名:继承方式 基类名 { 派生类成员声明 //派生类新增的数据成员和成员函数 }; 2.派生类生成过程: (1 继承除基类的构造函数和析构函数之外的所有数据成员和...

                     继承与派生

    1.派生类定义:

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

                   {

                      派生类成员声明

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

                   };

    2.派生类生成过程:

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

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

               (3 增加新的成员

    3.

    4.派生类构造函数:

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

               {

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

               }

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

      

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

              基类的构造函数

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

              派生类构造函数的函数体

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

    7.派生类的析构函数:

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

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

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

    多重继承的定义:

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

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

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

    10.虚基类:

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

    展开全文
  • C++继承派生

    2019-01-17 16:15:55
    信息科学技术学院《程序设计实习》,C++程序员入门级教程
  • C++派生类与继承

    2022-02-17 14:15:57
    继承派生其实都是一回事,只是说法不同罢了。 如:子类继承了父类,父类派生了子类。... 在编写代码的时候类与类之间也一样,子类拥有上一级类的共性,又拥有自己的特性!这个时候就可以利用继承的特性减少代...

            继承和派生其实都是一回事,只是说法不同罢了。
            如:子类继承了父类,父类派生了子类。

    那么什么是继承呢

            首先,如上图所示是一个动物种类区分图。猫和狗都属于动物这一种类,而猫又可以细分为加菲猫、布偶猫等种类。我们发现这些细分出来的单体在拥有上一级别的共性之外,还有各自的共性。比如加菲猫和布偶猫体型、毛发品质不同,但他们都属于猫类。
            在编写代码的时候类与类之间也一样,子类拥有上一级类的共性,又拥有自己的特性!这个时候就可以利用继承的特性减少代码的重复性!!

    一、基类 & 派生类

            当创建一个类时,不需要重新编写新的数据成员和成员函数,只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类,新建的类称为派生类

            例如我们看到很多网站中,都有公共的头部,公共的底部,甚至公共的左侧列表,只有中心内容不同。

    #include <iostream>
    using namespace std;
    
    //基类
    class basepage {
    	public:
    		void header()
    		{
    			cout << "首页、公开课、登录、注册...(公共头部)" << endl;
    		}
    		void footer()
    		{
    			cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
    		}
    		void left()
    		{
    			cout << "Java,Python,C++...(公共分类列表)" << endl;
    		}
    };
    
    //派生类
    class CPP :public basepage {
    public:
    	void content() {
    		cout << "C++学科视频" << endl;
    	}
    };
    
    void test01()
    {
    	//C++页面
    	cout << "C++下载视频页面如下: " << endl;
    	CPP cp;
    	cp.header();
    	cp.footer();
    	cp.left();
    	cp.content();
    }
    
    int main() {
    	test01();
    	system("pause");
    	return 0;
    }
    
    
    

            运行结果:

             从运行结果可以看出,CPP类在定义自己的特性基础上还保留basepage类的属性,这就是派生的基本用法。

            一个类可以派生自多个类,这意味着,它可以从多个基类继承数据和函数。定义一个派生类,我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名,形式如下:

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

            其中继承属性有public、private、protected三种 。

    多继承的方式如下:

            语法:class 派生类:继承方式 基类1 ,继承方式 基类2

    二、继承方式

            前面说了类的继承方式有三种public、private、protected,他们的区别就是派生类对基类的访问权限有所不同!

    • 公有继承(public):当一个类派生自公有基类时,基类的公有成员也是派生类的公有成员,基类的保护成员也是派生类的保护成员,基类的私有成员不能直接被派生类访问,但是可以通过调用基类的公有保护成员来访问。
    • 保护继承(protected): 当一个类派生自保护基类时,基类的公有保护成员将成为派生类的保护成员。
    • 私有继承(private):当一个类派生自私有基类时,基类的公有保护成员将成为派生类的私有成员。

            代码如下:

    #include <iostream>
    using namespace std;
    
    //
    //**继承方式一共有三种:**
    //
    //* 公共继承
    //* 保护继承
    //* 私有继承
    
    class base1 {
    public:
    	int m_a;
    protected:
    	int m_b;
    private:
    	int m_c;
    };
    
    //公有派生
    class son1 :public base1 {
    public:
    	void func() {
    		m_a;	//可访问public权限
    		m_b;	//可访问protected权限
    		//m_c;	//m_c是基类的私有权限无法访问
    	}
    };
    
    //保护派生
    class son2 :protected base1 {
    public:
    	void func() {
    		m_a;	//可访问protected权限
    		m_b;	//可访问protected权限
    		//m_c;	//m_c是基类的私有权限无法访问
    	}
    };
    
    //保护派生
    class son3 :private base1 {
    public:
    	void func() {
    		//m_a;	//不可访问private权限
    		//m_b;	//不可访问private权限
    		//m_c;	//m_c是基类的私有权限无法访问
    	}
    };
    
    
    void test() {
    	son1 s;
    	s.m_a;
    	//s.m_b; 公有派生不改变成员变量的权限,因此m_b是保护权限,类外无法访问
    
    	son2 s1;
    	//s1.m_a;	//protected权限,类外无法访问
    }
    
    int main()
    {
    	system("pause");
    	return 0;
    }

    三、继承的对象模型

            从父类继承过来的成员变量,哪些属于子类对象中?我们已经知道当发生公有继承的时候,不会改变基类成员变量的访问权限。
            并且在派生类中,无法访问基类中private属性的成员变量。无法访问并不意味着没有继承到派生对象中。可以看到如下代码:

    #include <iostream>
    using namespace std;
    
    //基类
    class base {
    public:
    	int m_a;
    protected:
    	int m_b;
    private:
    	int m_c;
    };
    
    class son1 :private base {
    public:
    	int m_d;
    };
    
    void test() {
    	cout << "son1 的 size = " << sizeof(son1) << endl;
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }

     运行结果:

             可以看出类son1的大小有16个字节,可以得出结论:派生类会继承基类中的private权限的成员变量。

            一个派生类继承了所有的基类方法,但如下三种情况除外:

    • 基类的构造函数、析构函数和拷贝构造函数。
    • 基类的重载运算符。
    • 基类的友元函数。

    四、基类和派生类构造/析构函数执行的顺序

            

    #include <iostream>
    using namespace std;
    
    class base {
    public:
    	base() {
    		cout << "base构造函数" << endl;
    	}
    	~base() {
    		cout << "base析构函数" << endl;
    	}
    };
    
    class son :public base {
    public:
    	son() {
    		cout << "son构造函数" << endl;
    	}
    
    	~son() {
    		cout << "son析构函数" << endl;
    	}
    };
    
    void test() {
    	son b1;
    }
    
    int main()
    {
    	test();
    	system("pause");
    	return 0;
    }
    

    运行结果:

            从运行结果可以看出在派生中,先执行基类的构造函数,再执行派生类的构造函数(肯定现有爸爸,才有儿子嘛)。析构函数顺序则与前者相反!

    五、同名成员变量(函数)的处理

            有时候我们会遇到派生类和基类出现同名成员函数和成员变量的问题,这时派生类会隐藏基类类中所有版本的同名成员函数。
            即在派生类定义的对象中访问同名成员变量(函数)的时候,执行的是派生类中。如果想访问基类中的成员变量(函数),就需要基类作用域。

    #include <iostream>
    using namespace std;
    
    class base {
    public:
    	base() {
    		m_a = 100;
    	}
    	void func() {
    		cout << "base -func()的调用" << endl;
    	}
    
    	void func(int a) {
    		cout << "base -func(int a)的调用" << endl;
    	}
    public:
    	int m_a;
    };
    
    class son :public base {
    public:
    	son() {
    		m_a = 200;
    	}
    
    	//当子类与父类拥有同名的成员函数,子类会隐藏父类中所有版本的同名成员函数
    	//如果想访问父类中被隐藏的同名成员函数,需要加父类的作用域
    	void func()
    	{
    		cout << "Son - func()调用" << endl;
    	}
    
    public:
    	int m_a;
    };
    
    void test01() {
    	son s;
    
    	cout << "son下的 m_a:" << s.m_a << endl;
    	cout << "base下的 m_a:" << s.base::m_a << endl;
    
    	s.func();
    	s.base::func();
    	s.base::func(10);
    }
    
    int main()
    {
    	test01();
    	system("pause");
    	return 0;
    }

    运行结果:

     六、同名静态成员变量(函数)的处理

            除了遇到同名成员变量(函数),有时还会遇到同名的静态成员变量(函数)。与前者相似,为了访问基类的同名对象,需要加上作用域。只不过静态成员变量(函数)有两种访问方式:

            ①通过对象访问
            ②通过类名访问

    #include <iostream>
    using namespace std;
    
    class base {
    
    public:
    	static void func() {
    		cout << "base static void func()" << endl;
    	}
    	static void func(int a) {
    		cout << "base static void func(int a)" << endl;
    	}
    
    public:
    	static int m_a;
    };
    
    int base::m_a = 10;	/*类的静态成员变量,类内声明,类外定义*/
    
    class son:public base {
    public:
    	static void func() {
    		cout << "son static void func()" << endl;
    	}
    
    public:
    	static int m_a;
    };
    
    int son::m_a = 20;
    
    //同名静态成员属性
    void test01() {
    	//通过对象访问
    	cout << "通过对象访问" << endl;
    	son s1;
    	cout << "son 下的m_a:" << s1.m_a << endl;
    	cout << "base 下的m_a:" << s1.base::m_a << endl;
    
    	//静态成员变量可以通过类名进行访问
    	cout << "通过类名进行访问" << endl;
    	cout << "son 下的m_a:" << son::m_a << endl;
    	cout << "base 下的m_a:" << son::base::m_a << endl;
    }
    
    //同名静态成员函数
    void test02() {
    	//通过对象访问
    	cout << "通过对象访问静态同名成员函数" << endl;
    	son s2;
    	s2.func();
    	s2.base::func();
    
    	//通过类名访问
    	son::func();
    	son::base::func();
    	son::base::func(10);
    }
    
    int main()
    {
    	test01();
    	test02();
    	system("pause");
    	return 0;
    }

    运行结果:

     七、菱形继承问题

            菱形继承,虚继承_audience_fzn的博客-CSDN博客

            两个派生类继承同一个基类,又有某个类同时继承两个派生类这种继承被称为菱形继承。这个时候,就会发生数据的二义性

            因为最后的类继承了2次,原始基类的特性。为了解决这种情况引入了virtual关键字。代码如下:

    #include <iostream>
    using namespace std;
    
    class animal {
    public:
    	int m_age;
    
    };
    
    //sheep继承animal
    class sheep:virtual public animal {
    
    };
    
    class Tuo:virtual public animal {
    
    };
    
    class sheepTuo:public sheep, public Tuo {
    
    };
    
    void test01() {
    	sheepTuo s;
    	s.sheep::m_age = 100;
    	s.Tuo::m_age = 200;
    	cout << "s.sheep::m_age=" << s.sheep::m_age << endl;
    	cout << "s.Tuo::m_age=" << s.Tuo::m_age << endl;
    }
    
    int main()
    {
    
    	test01();
    	system("pause");
    	return 0;
    }

            继承前加virtual关键字后,变为虚继承。此时公共的父类Animal称为虚基类

    运行结果:

    展开全文
  • 继承与派生总结

    2018-06-19 18:07:34
    c++继承与派生总结 面向对象的程序设计中提供了的继承机制,允许程序员在保持原有特性的基础上,进行更具体、更详细的的定义。以原有的为基础产生新的,我们就说新继承了原有的特征,也就是说从原有...
  • c++继承派生的讲解,国科大老师的课件。。。。。。。
  • 从bicycle和motorcar派生出motorcycle,观察虚基类对继承的影响。 定义一个motorcycle的对象,分别调用run()和stop(),观察构造/析构函数的调用情况。 注意:构造函数和析构函数中均为cout语句,说明哪个构造/析构...
  • c++程序设计 继承与派生实验(二) 1. 进一步掌握派生与继承的概念、应用方法 2. 掌握继承方式对成员访问权限的影响 3. 掌握虚基类的用法
  • 继承与派生;继承与派生问题举例;继承与派生问题举例;继承与派生问题举例;继承与派生问题举例;继承与派生的目的;派生类的声明;派生类生成过程;继承方式;公有继承(public;例7-1 公有继承举例;class Rectangle: ...
  • c++类继承与派生--实验报告.doc
  • C++05继承与派生 _C++_colorz6q_源码
  • C++类继承派生

    2020-04-03 17:41:50
    C++ 继承 面向对象程序设计的三大特性之一:继承 人类可以封装成一个,学生是一个。由于学生也是人类,所以可以继承人类这个中的方法和属性。 man称为父类、基类或者超类 Student称为派生类、子类 UML...
  • protected public 和 private 一样是用来声明成员的访问权限的。由protected声明的成员...在定义一个派生类时将基类的继承方式指定为protected的,称为保护继承,用保护继承方式建立的派生类称为保护派生类(protec
  • 实验三 派生类与继承 班级123班 姓名朱广金 学号122536 一实验目的 1学习继承能够定义和使用继承关系 2学习派生类的声明定义方法 3掌握的定义和对象的声明 4熟悉公有派生和私有派生的访问特性 5掌握派生...
  • c++课件 派生类与继承

    2012-05-08 15:51:57
    c++课件 派生类与继承
  • C++类继承派生类的构造函数

    千次阅读 2019-04-29 11:27:54
    这意味着派生类的构造函数必须使用基类的构造函数来设置从基类中继承的私有成员。 因此,在程序使用派生类构造函数创建派生类对象之前,要使用基类构造函数创建基类对象。C++中,使用成员初始化列表完成这种工作。 ...
  • C++派生类与继承(超详细)

    千次阅读 2020-08-15 16:57:30
    二、派生类的构造函数析构函数 2.1、派生类构造函数和析构函数的执行顺序 通常情况下,当创建派生类对象时, 首先执行基类的构造函数, 随后再执行派生类的构造函数; 当撤消派生类对象时, 则先执行派生类的析构函数, ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 107,704
精华内容 43,081
关键字:

c++类的继承与派生

c++ 订阅