精华内容
下载资源
问答
  • c++继承和派生
    2021-12-13 18:19:24

    执行派生类构造函数的顺序为:
    1)调用基类的构造函数,初始化基类的数据成员;
    2)初始化派生类的数据成员;
    3)执行派生类的构造函数本身。
    派生类的析构函数相对简单,与无继承关系的普通类的析构函数形式相同。执行析构函数的顺序为:
    1)调用派生类的析构函数;
    调用基类的析构函数

    更多相关内容
  • C++继承和派生

    2019-01-17 16:15:55
    信息科学技术学院《程序设计实习》,C++程序员入门级教程
  • 继承是是指一个对象直接使用另一对象的属性方法。 继承的作用: 1.描述客观事物的层次结构 2.分类的方法进行分析描述 3.复杂的系统层次化,提高代码的重用性 4.增强语言功能,提高软件开发效益 继承分为单...
  • c++继承和派生.doc

    2022-01-13 10:44:43
    根据c++第三版梳理的知识点。描述了第12章节继承和派生的知识点
  • C++继承和派生实例

    2014-12-29 10:28:49
    入门基础实例 有关继承和派生的应用小程序 希望对大家有帮助
  • 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
    */
    

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

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

     

     

    展开全文
  • c++继承和派生的理解

    2017-10-01 20:48:19
    继承:在定义一个新的类B时,如果该类与某个已有的类A相似(指的是B拥有A的全部特点),那么就可以把A作为一个基类,而把B作为基类的一个派生类(也称子类)。  派生类是通过对基类进行修改扩充得到的。在派生类中,...

    定义 

    继承:在定义一个新的类B时,如果该类与某个已有的类A相似(指的是B拥有A的全部特点),那么就可以把A作为一个基类,而把B作为基类的一个派生类(也称子类)。

        派生类是通过对基类进行修改和扩充得到的。在派生类中,可以扩充新的成员变量和成员函数。

    派生类拥有基类的全部成员函数和成员变量,不论是private、protected、public 。

    在派生类的各个成员函数中,不能访问基类中的private成员。

    派生类可以有自己的成员函数 如果和基类成员函数同名将覆盖。

    派生类对象的体积,等于基类对象的体积,再加上派生类对象自己的成员变量的体积。

    在派生类对象中,包含着基类对象,而且基类对象的存储位置位于派生类对象新增的成员变量之前。


    继承方式的问题: 继承方式可以是public,private和protected 

    这用于说明派生类的实例对象和派生类的派生类对其从基类继承来的成员变量的访问控制!

    对于class 默认省略继承方式时采用private继承方式!

    派生类会继承基类的所有成员,那么基类的成员将会变成派生类的什么成员?

    这是由于基类成员的访问机制和派生类的继承方式共同决定的。

    public:

    基类的public成员在派生类中成为public成员。

    基类的protected成员在派生类中成为protected成员。

    基类的private成员在派生类中成为不可直接使用的成员。

    private:

    基类的public成员在派生类中成为private成员。

    基类的protected成员在派生类中成为private成员。

    基类的private成员在派生类中成为不可直接使用的成员。

    protected:

    基类的public成员在派生类中成为protected成员。

    基类的protected成员在派生类中成为protected成员。

    基类的private成员在派生类中成为不可直接使用的成员。

    除了基类的private成员其余成员均可以在基类中调整其访问控制!

    调整方式:

    调整方式:基类名::基类成员名;



    定义派生类的时候一定要见到基类的定义,定义一个类的时候就是要告诉编译器要给这个类对象分配多大的内存,

    如果没有基类的定义,编译器就不知道要给派生类分配多大的内存!

    一般来说,基类的友元函数不是派生类的友元函数。

    -----------------------------------------------------------------------------------------------------------------------------------------------------

    类之间的关系:

    第一种:继承关系 -“是”的关系。

    基类 A,B是基类A的派生类。
    –逻辑上要求:“一个B对象也是一个A对象”。

    第二种:复合关系-“有”的关系。

    –类C中“有”成员变量k,k是类D的对象,则C和D是复合关系
    –一般逻辑上要求:“D对象是C对象的固有属性或组成部分”。


    访问范围说明符
    5 基类的private成员: 可以被下列函数访问
    •基类的成员函数
    •基类的友员函数 基类的public成员: 可以被下列函数访问
    •基类的成员函数
    •基类的友员函数
    •派生类的成员函数
    •派生类的友员函数
    •其他的函数

    基类的protected成员: 可以被下列函数访问
    •基类的成员函数
    •基类的友员函数
    •派生类的成员函数可以访问当前对象的基类的保护成员

    尤其注意访问从基类继承的protected成员! 

    派生类的成员函数只能访问当前对象的protected成员,也就是通过this指针访问,

    非当前对象的不可以访问。

    ------------------------------------------------------------------------------------------------------------

    访问控制:

    public:成员的访问不受控制,在程序的任何地方都可以访问一个类的public成员。

    private:成员只能在本类和友元中访问。

    protected:成员只能在本类,派生类和友元中访问。


    派生类对象 包含 基类对象 执行派生类构造函数之前, 先执行基类的构造函数

    在 创建 派生类的对象 时,
    •需要调用 基类的构造函数:
    初始化派生类对象中从基类继承的成员
    •在执行一个派生类的构造函数之前,
    总是先执行基类的构造函数

    所以在进入派生类的构造函数之前需要显示的调用基类的构造函数,也就是用初始化列表的形式先初始化基类的成员变量。

    调用基类构造函数的两种方式
    •显式方式:
    派生类的构造函数中  基类的构造函数提供参数
    derived::derived(arg_derived-list):base(arg_base-list)
    •隐式方式:
    派生类的构造函数中, 省略基类构造函数时
    派生类的构造函数, 自动调用基类的默认构造函数 派生类的析构函数被执行时, 执行完派生类的析构函数后, 自动调用基类的析构函数

    调用基类的默认构造函数前提得有默认构造函数!一旦重写了构造函数,编译器就不会在生成默认构造函数。


    创建 派生类的对象 时, 执行 派生类的构造函数 之前:
    •调用 基类 的构造函数
     初始化派生类对象中从基类继承的成员
    •调用 成员对象类 的构造函数
    初始化派生类对象中成员对象 执行完 派生类的析构函数 后:
    •调用 成员对象类 的析构函数
    •调用 基类 的析构函数 析构函数的调用顺序与构造函数的调用顺序相反







    展开全文
  • C++继承和派生笔记

    千次阅读 2019-10-24 12:52:32
    继承和派生 class Student:public Person 派生类把基类全部的成员(不包括构造函数解析函数)继承下来 公有继承 基类成员继承派生类后,其访问权限不变,但基类成员的私有成员在派生类中不可以直接访问 私有...

    继承和派生

    class Student:public Person
    

    派生类把基类全部的成员(不包括构造函数和解析函数)继承下来

    公有继承

    基类成员继承给派生类后,其访问权限不变,但基类成员的私有成员在派生类中不可以直接访问

    私有继承

    基类中的所有成员都以私有成员身份出现在派生类中,基类的私有成员在派生类中不可直接访问

    保护成员和保护继承

    从用户的角度来看,保护成员等价于私有成员,但是有一点不同,保护成员可以被派生类的成员函数使用

    在保护继承中,基类的公有和保护成员都以保护成员的身份出现在派生类中,而基类的私有成员不可以直接访问

    派生类的构造函数

    class Person
    {
    public:
    	Person()
    	{
    		id = 1;
    		name = "";
    		sex = 'L';
    	}
        Person(int id,string name,char sex)
        {
            this->id = id;
            this->name = name;
            this->sex = sex;
        }
    private:
        int id;
        string name;
        char sex;
    };
    
    class Student:public Person
    {	
    	// 在派生类构造函数的形参列表中,要给出初始化基类和派生类的数据成员所需要的全部参数	
    	Student(int id,string name,char sex,float score):Person(id,name,sex)
    	{
    		this->score = score;
    	}
    private
    	float score;
    };
    

    当创建一个派生类的对象时,系统首先自动调用基类构造函数,再调用派生类的构造函数。

    如果一个类只作为基类使用,一般不会用于实例化对象,就会把这个基数的数据成员和构造函数设置为protected访问权限,这样既保证了数据的封装性,又能在派生类中访问,保证了数据的一致性。

    派生类的析构函数

    先执行派生类的析构函数,然后调用基类的析构函数。

    多继承

    #include<iostream>
    using namespace std;
    class A
    {
    public:
        A(int x)
        {
            this->x = x;
        }
    private:
        int x;
        
    };
    class B
    {
    public:
        B(int y)
        {
            this->y = y;
        }
    private:
        int y;
    };
    
    class C:public A,public B
    {
    public:
    	C(int x,int y,int z):A(x),B(y)
    	{
    		this->z = z;
    	}
    private:
    	 int z;
        
    }
        
    

    同名函数的屏蔽:

    如果派生类和基类的函数同名,但是参数不同,此时,无论有没有virtual关键字,基类函数被隐藏。

    如果函数同名,参数相同,并且无virtual关键字,基类函数被隐藏。(注意和函数重写的区别)

    采用:“对象名.基类名::成员名”唯一访问函数

    多继承的时候可能会产生二义性问题。c++提供虚基类的方法,当基类通过多个路径被一个派生类继承时,该派生类只继承该基类一次。

    class A:virtual public M

    类的组合

    继承时纵向的,组合是横向的。

    #include<iostream>
    using namespace std;
    class Point
    {
        
    public:
        Point():x(0),y(0)
        {
            cout<<"Point's default constructor was called"<<endl;
        }
        Point(double x,double y):x(x),y(y)
        {
            cout<<"Point's constructor was called"<<endl;
        }
        Point(Point &p)
        {
            x = p.x;
            y = p.y;
            cout<<"Point's copyConstructor was called"<<endl;
        }
    private:
        double x;
        double y;
    };
    
    class Line
    {
    public:
    	Line():A(),B()
        {}
        
        Line(double x1,double y1,double x2,double y2):A(x1,y1),B(x2,y2)
        {}
        
        Line(Point p1,Point p2):A(p1),B(p2)
        {}
    Private:
        Point A;
        Point B;
    };
    

    基类和派生类的转换

    不能把一个整形数据赋值给指针变量

    可以用派生类对象对基类对象进行赋值,并且具有赋值兼容性(公有继承)

    多态性与虚函数

    虚函数

    满足的条件:

    • 基类与子类之间为公有继承方式
    • 基类函数要声明为虚函数
    • 通过基类指针或者引用来调用函数
    class A
    {
    public:
    	virtual void display
    	{}
    };
    class B:public A
    {
    public:
    	void display
    	{}
    }
    
    void main()
    {
    	A *pa;
    	B ba;
    	pa = &ba;
    	pa->display();
    	// 虽然pa是A类的对象,但是执行的是B类的display()
    }
    
    
    

    在运行过程中,根据基类指针指向不同的派生类对象就可以访问响应对象的虚函数,从而实现了运行时的动态多态性。派生类的虚函数重写或者覆盖了基类的同名虚函数。

    注意

    • virtual关键字只能出现在虚函数的原型声明中,在虚函数的实现中不能出现。
    • 将基类中的某一个成员声明为虚函数后,派生类中的同名函数(函数名相同,参数列表完全一样,返回值类型相同)自动成为虚函数。
    • 如果声明了某个成员函数为虚函数,则在该类中不能出现同名函数(函数名相同,参数列表完全一样,返回值类型相同),在以该类为基类的派生类中,也不能出现同名函数。
    • 非类的成员函数不能定义为虚函数,类的成员函数中静态成员函数和构造函数不能定义为虚函数,当可以将析构函数定义为虚函数。
    • 声明虚函数的时候,必须实现函数体。
    • 当通过基类指针删除指向子类的动态对象时,子类的析构函数没有被执行,说明子类对象动态分配的空间没有得到释放,造成了内存泄露。为解决这个问题,常常将基类的析构函数定义为虚函数。

    纯虚函数

    virtual void Area(); //错误,必须在基类中实现
    virtual void Area()
    {
    }
    //正确
    virtual void Area() = 0;
    //纯虚函数
    

    抽象类

    不用实例化对象,只作为一种“模板”用于派生的类,成为抽象类。

    运算符重载

    A operate+ (A &a1,A &a2)
    {
    	int x = a1.x + a2.x;
    	A a(x);
    	return a;
    
    }
    //定义一种新的加法算法
    

    一般来说,重载函数中要用到一些private的变量,所以一般把重载函数定义为友元函数。

    friend A operate+ (A &a1,A &a2);

    有两个实例!!

    展开全文
  • 所以继承和派生的关系就像小学时把字句被字句的造句一样。有了继承派生后,就有了父类/基类与子类/派生类,C++中将类B称为父类/基类,将类A称为子类/派生类。 派生类的声明: #include using namespace std;...
  • 1、C++继承的概念及语法 继承是类与类之间的关系,是一个很简单很直观的概念,与现实世界中的继承类似,例如儿子继承父亲的财产。 继承(Inheritance) 可以理解为一个类从另一个类获取成员变量成员函数的过程...
  • 第九章继承与派生类 92 典型例题分析与解答 例题 1下列对派生类的...答案D 分析一个派生类可以作为另一个派生类的基类无论是单继承还是多继承派生类至少有 一个基类派生类的成员除了它自己的成员外还包含了它的基类成员
  • c++继承和派生 ppt

    2011-12-06 16:46:22
    继承和派生课件
  • 【C++】C++继承和派生类、虚基类

    万次阅读 多人点赞 2018-06-07 18:46:17
    从已有的对象类型出发建立一种新的对象类型,使它部分或全部继承原对象的特点功能,这是面向对象设计方法中的基本特性之一。继承不仅简化了程序设计方法,显著提高了软件的重用性,而且还使得软件更加容易维护。...
  • C++继承和派生类有什么区别 ?联系 为什么要做出这样的区分
  • 继承和派生概述: 继承和派生是同一个过程从不同角的度看 保持已有类的特性而构造新类的过程称为继承。 在已有类的基础上新增自己的特性而产生新类的过程称为派生。 被继承的已有类称为基类...
  • C++ 上课/复习ppt继承派生.ppt
  • C++继承派生ppt

    2011-11-19 16:38:32
    很不错的C++课件,简单易懂,适合自学。深入浅出指点到位
  • 实验四 C++中的继承派生 一实验目的 理解C++继承派生的概念 掌握C++中各种不同继承方式的访问属性差别 掌握单继承与多继承的实现方法 掌握派生类构造函数与析构函数的实现及调用顺序 掌握虚基类的使用方法 二...
  • 造福学弟学妹系列:C++继承和派生实验报告

    千次阅读 多人点赞 2018-05-22 21:03:14
    1、学习声明使用类的继承关系,声明派生类 2、熟悉不同继承方式下对基类成员的访问控制 3、学习利用虚基类解决二义性问题 二、实验任务 1、声明一个基类Animal,有私有整型成员变量age,构造其派生类dog,在其...
  • C++继承派生的异同点

    千次阅读 2016-10-31 22:01:02
    C++继承派生的异同点 在C++中,面向对象有三大特性:封装、继承、多态。今天主要是想写点C++有关继承与多态的内容。 1、基本概念 类的继承是一个新的类从已有的类那里得到已有的特性; 类的派生是从已有的类...
  • C++派生类与继承

    2022-02-17 14:15:57
    继承和派生其实都是一回事,只是说法不同罢了。 如:子类继承了父类,父类派生了子类。 那么什么是继承呢 首先,如上图所示是一个动物种类区分图。猫狗都属于动物这一种类,而猫又可以细分为加菲猫、布偶猫等...
  • 脑图 代码 #include "stdafx.h" #include <iostream> using namespace std; class Vehicle { public: int MaxSpeed; int Weight; void Run(){cout<<"Vehicle run"<... void Stop(){cout&l...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 102,942
精华内容 41,176
关键字:

c++继承和派生