C++ 继承与派生

最新推荐文章于 2024-07-13 21:27:21 发布
最新推荐文章于 2024-07-13 21:27:21 发布
阅读量169 收藏
点赞数
分类专栏： C++ 提高 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43414070/article/details/121076624
版权

C++ 继承与派生

定义

类的继承，是新的类从已有类那里得到已有的特性。或从已有类产生新类的过程就是类的派生。原有的类称为基类或父类，产生的新类称为派生类或子类。派生与继承，是同一种意义两种称谓。

1. 继承

1.1 语法

class 派生类名：[继承方式] 基类名
{
	派生类成员声明；
};

一个派生类可以同时有多个基类，这种情况称为多重继承，派生类只有一个基类，称为单继承。下面从单继承讲起。

1.2 继承方式

继承方式规定了如何访问基类继承的成员。继承方式有 public, private, protected。继承方式不影响派生类的访问权限，影响了从基类继承来的成员的访问权限，包括派生类内的访问权限和派生类对象。

公有继承：基类的公有成员和保护成员在派生类中保持原有访问属性，其私有成员仍为基类的私有成员。

私有继承：基类的公有成员和保护成员在派生类中成了私有成员，其私有成员仍为基类的私有成员。

保护继承：基类的公有成员和保护成员在派生类中成了保护成员，其私有成员仍为基类的私有成员。

pretected 对于外界访问属性来说，等同于私有，但可以派生类中可见。

1.3 派生类的组成

派生类中的成员，包含两大部分，一类是从基类继承过来的，一类是自己增加的成员。从基类继承过过来的表现其共性，而新增的成员体现了其个性。
在这里插入图片描述

1.4 注意事项

1，全盘接收，除了构造器与析构器。基类有可能会造成派生类的成员冗余，所以说基类是需设计的。
2，派生类有了自己的个性，使派生类有了意义。

2. 派生类的构造

派生类中由基类继承而来的成员的初始化工作还是由基类的构造函数完成，然后派生类中新增的成员在派生类的构造函数中初始化。

2.1 派生类构造函数的语法

派生类名::派生类名（参数总表）
	:基类名（参数表）,内嵌子对象（参数表）
{
	派生类新增成员的初始化语句; //也可出现地参数列表中
}
  • 构造函数的初始化顺序并不以上面的顺序进行，而是根据声明的顺序初始化。
  • 如果基类中没有默认构造函数(无参)，那么在派生类的构造函数中必须显示调用基类构造函数，以初始化基类成员。
  • 派生类构造函数执行的次序：
 基类-->成员-->子类

a 调用基类构造函数，调用顺序按照它们被继承时声明的顺序（从左到右）；
b 调用内嵌成员对象的构造函数，调用顺序按照它们在类中声明的顺序；
c 派生类的构造函数体中的内容。

2.2 代码示例

祖父类
student.h

class Student
{
public:
	Student(string sn,int n,char s);
	~Student();
	void dis();
private:
	string name;
	int num;
	char sex;
};

student.cpp

Student::Student(string sn, int n, char s)
	:name(sn),num(n),sex(s)
{
}
Student::~Student()
{
}
void Student:: dis()
{
	cout<<name<<endl;
	cout<<num<<endl;
	cout<<sex<<endl;
}

父类
graduate.h

class Graduate:public Student
{
public:
	Graduate(string sn,int in,char cs,float fs);
	~Graduate();
	void dump()
	{
		dis();
		cout<<salary<<endl;
	}
private:
	float salary;
};

graduate.cpp

Graduate::Graduate(string sn, int in, char cs, float fs)
	:Student(sn,in,cs),salary(fs)
{
}
Graduate::~Graduate()
{
}

类成员
birthday.h

class Birthday
{
public:
	Birthday(int y,int m,int d);
	~Birthday();
	void print();
private:
	int year;
	int month;
	int day;
};

bithday.cpp

Birthday::Birthday(int y, int m, int d)
	:year(y),month(m),day(d)
{
}
Birthday::~Birthday()
{
}
void Birthday::print()
{
	cout<<year<<month<<day<<endl;
}

子类
doctor.h

class Doctor:public Graduate
{
public:
	Doctor(string sn,int in,char cs,float fs,string st,int iy,int im,int id);
	~Doctor();
	void disdump();
private:
	string title; //调用的默认构造器，初始化为”” Birthday birth; 			
	Birthday birth; //类中声明的类对象
};

doctor.cpp

Doctor::Doctor(string sn, int in, char cs, float fs, string st, int iy,int im, int id)
	:Graduate(sn,in,cs,fs),birth(iy,im,id),title(st)
{
}
Doctor::~Doctor()
{
}
void Doctor::disdump()
{
	dump();
	cout<<title<<endl;
	birth.print();
}

main.cpp

int main()
{
	Student s("1",2001,'m');
	s.dis();
	cout<<"----------------"<<endl;
	Graduate g("2",2001,'x',2000);
	g.dump();
	cout<<"----------------"<<endl;
	Doctor d("3",2001,'y',3000,"doctor",2001,8,16);
	d.disdump();
	return 0;
}

2.3 小结

子类构造器中，要么显示的调用父类的构造器(传参)，要么隐式的调用。发生隐式调用时，父类要有无参构造器或是可以包含无参构造器的默认参数函数。子类对象亦然。

3.派生类的拷贝构造

3.1 格式

派生类::派生类(const 派生类& another)
	:基类(another),派生类新成员(another.新成员)
{
}

3.2 代码示例

父类
student.h

class Student
{
public:
	Student(string sn,int n,char s);
	Student(const Student & another);
	~Student();
	void dis();
private:
	string name;
	int num;
	char sex;
};

student.cpp

Student::Student(string sn, int n, char s)
	:name(sn),num(n),sex(s)
{
}
Student::~Student()
{
}
void Student:: dis()
{
	cout<<name<<endl;
	cout<<num<<endl;
	cout<<sex<<endl;
}
Student::Student(const Student & another)
{
	name = another.name;
	num = another.num;
	sex = another.sex;
}

子类
graduate.h

class Graduate:public Student
{
public:
	Graduate(string sn,int in,char cs,float fs);
	~Graduate();
	Graduate(const Graduate & another);
	void dump()
	{
		dis();
		cout<<salary<<endl;
	}
private:
	float salary;
};

graduate.cpp

Graduate::Graduate(string sn, int in, char cs, float fs)
	:Student(sn,in,cs),salary(fs)
{
}
Graduate::~Graduate()
{
}
Graduate::Graduate(const Graduate & another)
	:Student(another),salary(another.salary)
{
}

main.cpp

int main()
{
	Graduate g("123",2001,'x',2000);
	g.dump();
	Graduate gg = g;
	gg.dump();
	return 0;
}

3.3 小结

派生类中的默认拷贝构造器会调用父类中默认或自实现拷贝构造器，若派生类中自实现拷贝构造器，则必须显示的调用父类的拷贝构造器。

4. 派生类的赋值运算符重载

赋值运算符函数不是构造器，所以可以继承，语法上就没有构造器的严格一些。

4.1 格式

子类& 子类::operator=(const 子类& another)
{
	if(this == &another)
		return *this; //防止自赋值
	父类::operator =(another); // 调用父类的赋值运算符重载
	this->salary = another.salary;//子类成员初始化
	return * this;
}

4.2 代码示例

基类
student.h

Student & operator=(const Student & another);

student.cpp

Student & Student::operator=(const Student & another)
{
	this->name = another.name;
	this->num = another.num;
	this->sex = another.sex;
	return * this;
}

派生类
graduate.h

Graduate & operator=(const Graduate & another);

graduate.cpp

Graduate & Graduate::operator=(const Graduate & another)
{
	if(this == &another)
		return *this;
	Student::operator =(another);
	this->salary = another.salary;
	return * this;
}

4.3 小结

派生类的默认赋值运算符重载函数，会调用父类的默认或自实现函数。派生类若自实现，则不会发生调用行为，也不报错(区别拷贝)，赋值错误，若要正确，需要显示的调用父类的自实现函数。

5. 派生类友元函数

由于友元函数并非类成员，因此不能被继承，在某种需求下，可能希望派生类的友元函数能够使用基类中的友元函数。为此可以通过强制类型转换，将派生类的指针或是引用强转为其基类的引用或是指针，然后使用转换后的引用或是指针来调用基类中的友元函数。

#include <iostream>
using namespace std;
class Student
{
friend ostream &operator<<(ostream & out, Student & stu);
private:
	int a;
	int b;
};
ostream &operator<<(ostream & out, Student & stu)
{
	out<<stu.a<<"--"<<stu.b<<endl;
}
class Graduate:public Student
{
friend ostream &operator<<(ostream & out, Graduate & gra);
private:
	int c;
	int d;
};
ostream &operator<<(ostream & out, Graduate & gra)
{
	out<<(Student&)gra<<endl;
	out<<gra.c<<"**"<<gra.d<<endl;
}
int main()
{
	// Student a;
	// cout<<a<<endl;
	Graduate g;
	cout<<g<<endl;
	return 0;
}

在这里插入图片描述

6. 派生类析构函数的语法

派生类的析构函数的功能是在该对象消亡之前进行一些必要的清理工作，析构函数没有类型，也没有参数。析构函数的执行顺序与构造函数相反。
析构顺序

子类->成员->基类

7. 派生类成员的标识和访问

7.1 作用域分辨符

格式

基类名::成员名; 基类名::成员名（参数表）;

如果某派生类的多个基类拥有同名的成员，同时，派生类又新增这样的同名成员，在这种情况下**，派生类成员将 shadow(隐藏)所有基类的同名成员**。这就需要这样的调用方式才能调用基类的同名成员。

#include <iostream>
using namespace std;
class Base
{
public:
	void func(int)
	{
		cout<<"haha"<<endl;
	}
};
class Drive:public Base
{
public:
	void func()
	{
		Base::func(3); //被 shadow 的成员，可以这样访问
		cout<<"hehe"<<endl;
	}
};
int main()
{
	Drive d;
	d.func(); // 访问派生类成员
	d.Base::func(3); //访问基类成员
	return 0;
}

在这里插入图片描述

7.2 小结

重载：同一作用域 ，函数同名不同参(个数，类型，顺序);
隐藏：父子类中，标识符(函数，变量)相同，无关乎返回值和参数(函数)，或声明类型(变量)。

8. 多继承

从继承类别上分，继承可分为单继承和多继承，前面讲的都是单继承。

8.1 意义

俗话讲的，鱼与熊掌不可兼得，而在计算机就可以实现，生成一种新的对象，叫熊掌鱼，多继承自鱼和熊掌即可。还比如生活中，“兼”。

8.2 语法

派生类名::派生类名（参数总表）
	:基类名 1（参数表 1），基类名（参数名 2）....基类名 n（参数名 n），
	内嵌子对象 1（参数表 1），内嵌子对象 2（参数表 2）....内嵌子对象 n（参数表 n）
{
	派生类新增成员的初始化语句;
}

8.3 代码示例

床类
bed.h

#ifndef BED_H
#define BED_H
class Bed
{
public:
	Bed();
	~Bed();
	void sleep();
};
#endif // BED_

bed.cpp

#include "bed.h"
#include "iostream"
using namespace std;
Bed::Bed()
{
}
Bed::~Bed()
{
}
void Bed::sleep()
{
	cout<<"take a good sleep"<<endl;
}

沙发类
sofa.h

#ifndef SOFA_H
#define SOFA_H
class Sofa
{
public:
	Sofa();
	~Sofa();
	void sit();
};
#endif // SOFA_H

sofa.cpp

#include "sofa.h"
#include "iostream"
using namespace std;
Sofa::Sofa()
{
}
Sofa::~Sofa()
{
}
void Sofa::sit()
{
	cout<<"take a rest"<<endl;
}

沙发床类
sofabed.h

#ifndef SOFABED_H
#define SOFABED_H
#include "sofa.h"
#include "bed.h"
class SofaBed:public Sofa,public Bed
{
public:
	SofaBed();
	~SofaBed();
};
#endif // SOFABED_H

sofabed.cpp

#include "sofabed.h"
SofaBed::SofaBed()
{
}
SofaBed::~SofaBed()
{
}

main.cpp

#include <iostream>
#include "sofa.h"
#include "bed.h"
#include "sofabed.h"
using namespace std;
int main()
{
	Sofa s;
	s.sit();
	Bed b;
	b.sleep();
	SofaBed sb;
	sb.sit();
	sb.sleep();
	return 0;
}

8.4 二义性问题

多个父类中重名的成员，继承到子类中后，为了避免冲突，携带了各父类的作用域信息, 子类中要访问继承下来的重名成员，则会产生二义性，为了避免冲突，访问时需要还有父类的作用域信息。

#include <iostream>
using namespace std;
class X
{
public:
    X(int d):_data(d){}
    void setData(int i)
    {
        _data = i;
    }
    int _data;
};
class Y
{
public:
    Y(int d):_data(d){}
    int getData()
    {
        return _data;
    }
    int _data;
};
class Z:public X,public Y
{
public:
    Z():X(2),Y(3){}
    void dis()
    {
        cout<<X::_data<<endl;
        cout<<Y::_data<<endl;
    }
};
int main()
{
    Z z;
    z.dis();
    z.setData(2000);
    cout<<z.getData()<<endl;
    return 0;
}

输出结果

9. 虚继承

9.1 虚继承的意义

在多继承中，保存共同基类的多份同名成员，虽然有时是必要的，可以在不同的数据成员中分别存放不同的数据，但在大多数情况下，是我们不希望出现的。因为保留多份数据成员的拷贝，不仅占有较多的存储空间，还增加了访问的困难。
为此，c++提供了，虚基类和虚继承机制，实现了在多继承中只保留一份共同成员。 虚基类，需要设计和抽象，虚继承，是一种继承的扩展。

9.2 语法

a.M 类称为虚基类(virtual base class )，是抽象和设计的结果。
b.虚继承语法

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

c.虚基类及间接类的实始化

class A{
	A(int i)
	{}
};
class B:virtual public A
{
	B(int n):A(n){}
};
class C:virtual public A
{
	C(int n):A(n){}
};
class D:public B,public C
{
	D(int n)
		:A(n),B(n),C(n)
	{}
};

9.3 代码示例

#include <iostream>
using namespace std;
class M
{
public:
    M(int d):_data(d){}
    int _data;
};
class X :virtual public M
{
public:
    X(int d):M(d){}
    void setD(float d)
    {
        _data = d;
    }
};
class Y:virtual public M
{
public:
    Y(int d):M(d){}
    int getD()
    {
        return _data;
    }
};
class Z:public X,public Y
{
public:
    Z(int _x,int _y):X(_x),Y(_y),M(100){}
    void dis()
    {
       	cout<<X::_data<<endl;
        cout<<Y::_data<<endl;
        cout<<_data<<endl;
    }
};
int main()
{
    Z z(200,100);
    z.dis();
    z.setD(2000);
    cout<<z.getD()<<endl;
    return 0;
}

输出结果

ALL IN C
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++的继承与派生
qq_43965574的博客
02-19 313
公有public、保护protected、私有private 类的对象只可访问public的成员和函数，类内的成员函数可以访问全部成员和函数。
C++之继承与派生
有梦想的小新人的博客
12-11 613
文章目录1.类的继承与派生1.1 类的继承1.2 类的派生2.访问控制2.1公有继承2.22.3 1.类的继承与派生 1.1 类的继承 多继承和单继承：一个派生类可以同时有多个基类称为多继承： class Derived:public Base1,private Base2{}；一个派生类只有一个直接基类称为单继承： class Derived:public Base1{} 直接基类和间接基类：直接参与派生出某类的基类称为直接基类，基类的基类甚至更高的基类称为间接基类 在类的定义中，除了要指定基类外，还
继承与派生
clp20097522的专栏
11-12 633
继承和派生的相关概念和应用
C++知识复习（三）
柳牧文的博客
12-17 118
c++期末复习
C++primer学习笔记----面向对象程序设计（1）
u012677715的博客
06-11 567
面向对象程序设计的核心是数据抽象、继承和动态绑定（多态） 基类负责定义在层次关系中所有类共同拥有的成员，每个派生类定义各自特有的成员。 对于某些函数，基类希望它的派生类各自定义适合自身的版本，此时基类就将这些函数声明成虚函数。派生类必须在其内部对所有重新定义的虚函数进行声明。 C++语言中，当使用基类的引用（或指针）调用一个虚函数时将发生动态绑定。 基类通常都应该定义一个虚析构函数，即使该
C++继承与派生
01-20
　覆盖：派生类中定义一个与基类数据成员或成员函数同名的成员，则替换基类的成员。 　覆盖不是成员的重载，只是掩盖了从基类继承得到的同名成员，作用域声明后，仍可引用基类成员。可在派生类成员函数中引用基类...
c++继承与派生
01-19
C++继承与派生 本节课程主要介绍C++中继承与派生的概念和使用方法，包括公有继承、私有继承和保护继承等不同的继承方式。通过实验和实践，掌握继承与派生的基本概念和使用方法。 继承的概念 继承是面向对象编程中...
C++继承与派生PPT
08-31
C++课程资源，详细介绍C++继承与派生规则和使用情况
C++继承与派生.doc
08-17
在C++编程语言中，继承和派生是面向对象...总之，这个实验帮助我们掌握了C++中类的继承与派生，包括构造函数和析构函数的使用，以及不同继承方式的区别。通过实际编写和运行代码，加深了对面向对象编程核心概念的理解。
C++初探究（2）
Frenemy__的博客
07-09 1480
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 1015
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
05day--C++日期类的实现与取地址运算符的重载
weixin_73863912的博客
07-13 235
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
C++客户端Qt开发——QT初识
最新发布
m0_63596031的博客
07-13 525
②中的代码创建，是在堆上new出来的一块空间，当把对象改成在栈上创建，此时就可以看到运行起来的程序无法显示出helloworld，此时label对象随着构造函数的结束，就销毁了，所以应该把它交给对象树进行管理。在QT Designer中创建一个控件的时候，此时会给这个控件分配一个objectName属性，这个属性的值，要求是在界面中是唯一的，不能和别人重复。Qt的对象树模型是一种递归的结构，其中一个对象可以拥有多个子对象，而每个子对象又可以拥有自己的子对象，以此类推。坐标体系：以左上角为原点（0,0），
C语言操作符详解
z317920的博客
07-11 606
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引
C++：哈希表
m0_61088872的博客
07-12 485
如果我们想要搜索这个数据，直接计算出这个数据的下标，然后就可以直接访问数组对应的位置，所以可以用O(1)的复杂度直接找到数据。当这个哈希表越满，我们查找数据的效率就越低，甚至说：如果查找一个不存在的数据，我们可能要用O(N)的复杂度遍历整个哈希表.因此我们因该把哈希表的负载率控制在一定值，当超过一定值，我们就要进行扩容操作。闭散列，也叫做开放定址法，当发生哈希冲突时，如果哈希表没有被装满，说明哈希表中还有空位置，那么我们可以把发生冲突的数据放到下一个空位置去。转化的函数，被写为了一个模板，而这个。
深入解析【C++ list 容器】：高效数据管理的秘密武器
小李很执着的博客
07-09 942
C++ 中的 list 容器是一个基于双向链表的序列式容器，适用于需要频繁插入和删除操作的场景，但不支持随机访问。list 提供了多种构造方法和丰富的操作接口，包括插入、删除、访问等。与 vector 相比，list 在插入和删除操作上更高效，但在随机访问和空间利用率上较差。
Python的异常处理（与C++对比学习）
2302_76941579的博客
07-09 959
通过C++的基础来学习Python的异常处理
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
星羽空间
07-09 350
LIUNX /SYS/CLASS/GPIO捕获IO输入状态 C语言
[C++]——同步异步日志系统（3）
plj521的博客
07-10 1541
从本篇开始，正式开始写同步异步日志系统
c++继承与派生现实实例
11-28
以下是一个C++继承与派生的实例： 假设我们有一个基类Animal，它有一个成员函数eat()和一个成员变量name。现在我们想要创建一个派生类Dog，它继承了Animal类，并且有一个额外的成员函数bark()。我们可以这样定义Dog...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值