【C++】初始继承

已于 2023-03-31 22:27:24 修改
阅读量865 收藏 3
点赞数 1
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-03-29 22:36:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62714628/article/details/129821488
版权

文章目录

前言

继承的本质就是使代码可以被复用，被继承的类称为父类或基类，继承其他类的类称为子类或派生类。

一、使用语法

class Person
{
protected:
	int _age; //年龄
	string _sex; //性别
	string _name; //姓名
};

class Student :public Person
{
protected:
	int _id; //学号
	string _speciality; //专业
};
  • Person： 父类或基类
  • Student： 子类或派生类
  • public： 继承方式

继承的语法很简单，就是在你写完一个类后加上冒号（：），冒号后面跟上你要继承的类名，冒号左边的类就是子类，冒号右边的类就是父类，此时在子类和父类中间的public就是继承方式。

此外，继承方式也是可以省略不写的，如下：

class Student : Person
{
protected:
	int _id; //学号
	string _speciality; //专业
};

对于用class关键字修饰的类来说，如果不写继承方式，默认的继承方式就为private，而在C++中类不仅可以用class修饰，也可以用struct修饰，所以如果是继承自struct修饰的类，并且不显示指定继承方式的话，那么默认的继承方式就是public。

二、继承方式

首先明确C++ 继承中的三种继承方式：

  • public： 公有继承
  • protected： 保护继承
  • private： 私有继承

继承方式大小关系：public > protected > private

无论使用何种继承方式，父类的成员都会被继承到子类，只是根据继承方式与父类内部成员的访问限定符决定该部分成员能否在子类被访问和其在子类内部的访问限定符，举个例子：

class Person
{
public:
	Person(int age = 0, string sex = "", string name = "")
		:_age(age)
		,_sex(sex)
		,_name(name)
	{
		cout << "Person()" << endl;
	}
protected:
	int _age; //年龄
	string _sex; //性别
	string _name; //姓名
};

class Student :private Person
{
public:
	Student(int age = 0, string sex = "", string name = "", int id = 0, string speciality = "")
		:Person(age,sex,name)
		,_id(id)
		,_speciality(speciality)
	{
		cout << "Student()" << endl;
	}

	void Print()
	{
		cout << _age << _sex << _name << endl;
	}

protected:
	int _id; //学号
	string _speciality; //专业
};

此时的继承为private继承，因为父类中的成员的访问限定符都要大于我们的继承方式，所以父类中的成员我们在子类中都是可以使用的，而因为是private继承，继承到的成员的访问限定符都是private修饰的，所以这些继承到的成员只能在子类的内部使用，而不能在类外使用。

总的来说，一般建议继承方式都用public继承，因为如果protected、private继承下来的成员只能在子类的内部使用，扩展维护性不强，另外如果一个类要被另外的类继承，那么它的成员建议是protected、private修饰的，因为如果使用private修饰的话，就算子类继承了父类的成员，在子类内部也是无法访问父类的private成员的，这样算哪门子的继承？！

三、父类和子类的赋值转换

子类对象可以直接赋值给父类的对象、父类的指针、父类的引用，父类和子类的赋值转换有一个形象的叫法叫做切片或者切割，画图表示图下：
在这里插入图片描述
就是把子类和父类相同的成员给赋值过去，然而父类对象并不能直接赋值给子类对象，原因也很简单，子类有的成员父类并不完全拥有，所以不能完成赋值。

四、继承中的作用域

父类和子类有不同的作用域，如果父类和子类中有同名的元素，子类会优先使用自己内部的成员，而不访问父类的同名成员，这种情况叫做隐藏。

举个例子：
父类和子类都有_age这个同名成员，现在给它们赋不同的值，父类的_age为20，子类的_age为30，那么此时调用子类内部的Print()（打印函数）会调用那个_age呢？

class Person
{
public:
	Person(int age = 0, string sex = "", string name = "")
		:_age(age)
		,_sex(sex)
		,_name(name)
	{
		//cout << "Person()" << endl;
	}
protected:
	int _age; //年龄
	string _sex; //性别
	string _name; //姓名
};

class Student :private Person
{
public:
	Student(int age1 = 0, string sex = "", string name = "", int age2 = 0, string speciality = "")
		:Person(age1,sex,name)
		,_age(age2)
		,_speciality(speciality)
	{
		//cout << "Student()" << endl;
	}

	void Print()
	{
		cout << _age  << endl;
	}

protected:
	int _age; //学号
	string _speciality; //专业
};

int main()
{
	Person p;
	Student s(20, "男", "张三", 30, "计算机");
	s.Print();
	return 0;
}

在这里插入图片描述

运行结果：

在这里插入图片描述

可以看到，运行的是子类本身的_age，也表明了父类和子类有相同的成员，会隐藏父类的同名成员，而只访问本身的内部成员。

另外如果是成员函数的隐藏，那么只需要满足函数名相同即可构成，举个例子：

class Person
{
public:
	Person(int age = 0, string sex = "", string name = "")
		:_age(age)
		,_sex(sex)
		,_name(name)
	{
		//cout << "Person()" << endl;
	}
	
	void Print()
	{
		cout << "我是父类的打印函数" << endl;
	}

protected:
	int _age; //年龄
	string _sex; //性别
	string _name; //姓名
};

class Student :private Person
{
public:
	Student(int age1 = 0, string sex = "", string name = "", int age2 = 0, string speciality = "")
		:Person(age1,sex,name)
		,_age(age2)
		,_speciality(speciality)
	{
		//cout << "Student()" << endl;
	}

	void Print()
	{
		cout << "我是子类的打印函数" << endl;
	}

protected:
	int _age; //学号
	string _speciality; //专业
};

int main()
{
	Person p;
	Student s(20, "男", "张三", 30, "计算机");
	s.Print();
	return 0;
}

运行结果：

在这里插入图片描述

总的来说关于父类和子类中有同名的成员，子类会隐藏自父类中继承的同名成员，访问遵循就近原则。

五、子类的默认成员函数

子类的默认成员和普通类的默认成员是一致的，都是由构造函数、拷贝构造函数、析构函数、赋值运算符重载、取地址、const修饰的取地址所组成的。

但是毕竟子类继承了父类的成员，那么父类的成员在子类构造和析构时自然也要进行操作，具体操作规则如下：

  1. 构造函数： 子类对象在进行构造时，需要先调用父类的构造函数，去构造父类的成员，然后再调用子类自己的构造函数来构造自己的成员，如果父类内部没有实现默认的构造函数，那么子类在构造时就要在初始化列表显示的调用父类的构造函数对其进行构造，如下：
class Person
{
public:
	Person(int age = 0, string sex = "", string name = "")
		:_age(age)
		,_sex(sex)
		,_name(name)
	{
		cout << "Person()" << endl;
	}
	
	void Print()
	{
		cout << "我是父类的打印函数" << endl;
	}

protected:
	int _age; //年龄
	string _sex; //性别
	string _name; //姓名
};

class Student :private Person
{
public:
	Student(int age1 = 0, string sex = "", string name = "", int age2 = 0, string speciality = "")
		:Person(age1,sex,name)
		,_age(age2)
		,_speciality(speciality)
	{
		cout << "Student()" << endl;
	}

	void Print()
	{
		cout << "我是子类的打印函数" << endl;
	}

protected:
	int _age; //学号
	string _speciality; //专业
};

int main()
{
	Student s(20, "男", "张三", 30, "计算机");
	return 0;
}

运行结果：

在这里插入图片描述
可以清楚的看到在实例化是个Student（子类）对象时，先调用了父类的构造函数，然后再调用了子类自己的构造函数，如果父类没有默认构造函数，而此时子类的构造函数的初始化列表也没有显示的调用父类的构造函数，则会出现如下的情况：

在这里插入图片描述

  1. 析构函数： 子类对象在进行析构时，执行顺序是和构造函数反过来的，即先调用子类自己的析构函数，再调用父类的析构函数，这里析构函数就不用我们自己显示的调用了，编译器会在对子类自身进行析构之后，自动的调用父类的析构函数，如下：
class Person
{
public:
	Person(int age = 0, string sex = "", string name = "")
		:_age(age)
		,_sex(sex)
		,_name(name)
	{
		cout << "Person()" << endl;
	}
	
	~Person()
	{
		cout << "~Person()" << endl;
	}

	void Print()
	{
		cout << "我是父类的打印函数" << endl;
	}

protected:
	int _age; //年龄
	string _sex; //性别
	string _name; //姓名
};

class Student :private Person
{
public:
	Student(int age1 = 0, string sex = "", string name = "", int age2 = 0, string speciality = "")
		:_age(age2)
		,_speciality(speciality)
	{
		cout << "Student()" << endl;
	}

	~Student()
	{
		cout << "~Student()" << endl;
	}

	void Print()
	{
		cout << "我是子类的打印函数" << endl;
	}

protected:
	int _age; //学号
	string _speciality; //专业
};

int main()
{
	Student s(20, "男", "张三", 30, "计算机");
	return 0;
}

运行结果：

在这里插入图片描述
结果正好是和构造反着来的，其实也很好理解，如果先析构父类，那么此时子类继承的一些父类的成员进行访问时就会出错了，所以先析构子类是最好的。

  1. 拷贝构造和赋值运算符重载： 这两个函数也是先调用父类的拷贝构造对父类的成员进行构造，赋值也是先调用父类的赋值对父类的成员进行赋值。

六、继承与友元

友元关系是不能继承的，也就是说父类的友元，不能访问子类的protected成员和private成员。

举例：

class Person
{
	friend class f_class;
public:
	Person(int age = 0, string sex = "", string name = "")
		:_age(age)
		,_sex(sex)
		,_name(name)
	{
		//cout << "Person()" << endl;
	}
	
	~Person()
	{
		//cout << "~Person()" << endl;
	}

	void Print()
	{
		cout << "我是父类的打印函数" << endl;
	}

protected:
	int _age; //年龄
	string _sex; //性别
	string _name; //姓名
};

class Student :private Person
{
public:
	Student(int age1 = 0, string sex = "", string name = "", int age2 = 0, string speciality = "")
		:_age(age2)
		,_speciality(speciality)
	{
		//cout << "Student()" << endl;
	}

	~Student()
	{
		//cout << "~Student()" << endl;
	}

	void Print()
	{
		cout << "我是子类的打印函数" << endl;
	}

protected:
	int _age; //学号
	string _speciality; //专业
};

class f_class
{
public:
	void f_print()
	{
		Person().Print();
		Student()._age;
	}

};

int main()
{
	//Student s(20, "男", "张三", 30, "计算机");
	f_class f;
	f.f_print();
	return 0;
}

运行结果：

在这里插入图片描述
可以看到，虽然Student是继承Person这个类的，而f_class作为父类的友元类，它是不能访问Student的protected成员的。

七、继承与静态成员

父类里有一个static成员，那么无论多少个类继承了该类，整个继承体系里面都只有一份这个static成员，即继承该父类的子类都共享这一个static成员。

总结

温故而知新。

d4uu
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C++】继承
https://blog.csdn.net/WL0616
08-11 178
目录1.继承的概念及定义1.1继承的概念1.2继承的定义格式1.3继承基类成员访问方式的变化（1）公有继承（2）保护继承（3）私有继承1.4总结2.基类和派生类对象赋值转换3.继承中的作用域 1.继承的概念及定义 1.1继承的概念 继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 1.2继承的定义
成员初始化列表-适用场合
weixin_34166847的博客
08-10 193
1. 简述     主要的场合有四类：初始化对象成员，初始化基类的成员，初始化const成员，初始化引用成员。对于const成员和引用成员，比较简单，这两种变量都要求初始化后不能赋值，因此，只能在成员初始化列表中进行初始化，其他地方不行。本文主要介绍初始化对象成员和初始化基类成员这两种情况。   2. 初始化对象成员     具体分为两种情况：第一，该对象具有“无参数的构造函数”，使用初始...
c++初始化列表
cl2010abc的专栏
06-10 366
反对反对法
C++类构造函数初始化列表与子类向父类传参数
sinat_31608641的博客
12-05 4545
一、C++类构造函数初始化列表 class CExample { public: int a; float b; //构造函数初始化列表 CExample() : a(0), b(8.8) {} //构造函数内部赋值 CExample() { a = 0; b = 8.8; } }; 上面的例子中两个构造函数的结果是一样的。上面的构造函数（使用初始化列表的构造函数）显式的初始化类的成员；而没使用初始化列表的构造函数是对类的成员赋值，并没有进行显式的初始化。 初始化和赋值对内置
(10)C++继承初始
A_shmily_的博客
05-17 404
继承 基础涵盖 1.作用：增加代码的重用性 2.形式：包括基类/父类和派生类/子类 class CPeolpe//声明基类/父类 { public: void study() cout << "goto study" << endl; }; class Cchlid : public CPeolpe //继承父类的形式 { public: void school() cout << "goto school" << endl; }; 3.可.
C++初始化列表详解
weixin_42307601的博客
06-18 4226
本篇博客详细讲解初始化列表的用法、必须使用初始化列表场景、初始化列表的优缺点等。
C++继承
01-08
子类的默认成员函数 构造函数 先调用父类的默认构造, 初始化父类的成员 再调用子类的构造, 初始化子类的的成员 父类没有默认构造, 在子类初始化列表中显示调用父类的构造 ...菱形继承 : 数据冗余 二义性(钻石
实例代码讲解c++ 继承特性
12-17
在C++编程语言中，继承是一种面向对象编程的关键特性，它允许一个类（称为派生类）从另一个类（称为基类）继承属性和行为。继承的主要目的是代码重用和扩展，使得基类的特性可以作为派生类的基础，同时派生类可以...
c++多重继承
05-03
类的多重继承演示"<<endl; CDateTimeType dt 1 1 2008 11 12 12 ; 直接使用DateTimeType构造函数设置日期时间 cout<<"调用CDateTimeType类构造函数设定的初始日期 时间为："<<...
C++菱形继承分析
04-04
在C++中，当一个类从多个基类继承时，每个基类的构造函数都需要被调用以初始化对象。对于菱形继承，可能存在重复初始化基类子对象的情况。为了解决这个问题，C++引入了"二重继承"的概念，即在派生类构造过程中，先...
c++继承和派生.doc
01-13
C++中的继承和派生是面向对象编程的重要概念，它们允许创建新的类（派生类）基于现有的类（基类），从而实现代码的重用和类的层次结构。以下是关于继承和派生的详细说明： 12.1 继承的基本概念 继承是一种“is-a”...
C++进阶剖析（十 九）之继承
海是倒过来的天的博客
05-26 1090
1.1 继承是非常重要的，在面向对象编程中有着举足轻重的地位。尤其是在设计模式中。 1.1.1 生活中的继承 龙生龙，凤生凤，老鼠儿子会打洞。 生活中的继承是一种长相和行为的继承。 1.1.2 类之间的关系 组合关系（思想很重要） 一台电脑有CPU，主板，显示器等组成 继承关系（思想很重要） 电脑分为惠普，联想等（is a ） 1.1.3 1.2 类的组合关系 1.2.1代码实例 电...
C++中继承时的初始化列表和函数重载（overload）
WJ_SHI的博客
09-03 5785
在C++中的一个重要内容就是可继承性，继承后的子类拥有父类中的所有方法和属性，因此子类在继承后就可以对父类中的属性初始化。在类中可通过构造函数，对一个类中的属性采用列表的方式进行初始化，例如用一个程序来管理学生的基本信息： #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;sstream&gt; using names...
C++ 初始化列表详解
热门推荐
Allen Roson
01-08 1万+
C++ 初始化列表详解；什么是初始化列表；初始化列表注意事项
C++ 类继承的简单例子与理解
han_lx_的博客
04-20 924
1.构造函数与析构函数调用顺序 无其它类对象时： #include<iostream> using namespace std; class MyBase1 { public: MyBase1() { cout << "…BaseClass1 Object is created!" << endl; }//1 ~MyBase1() { cout << "…BaseClass1 Object is destroyed!" << endl;
C++面向继承时构造函数初始化
努力的八戒
09-26 1793
1、参数初始化 C++派生类不能继承基类的构造函数，对于派生类新增成员，派生类自定义构造函数初始化；对于继承来的成员，调用基类构造函数进行初始化。当基类没有默认构造函数时，派生类构造函数需要给基类构造函数传递参数，形如下面格式，具体可以参考virtual实现C++运行时多态一文中的实例： 派生类名：：派生类名（基类所需形参，本类成员所需形参）：基类名（参数表），本类成员初始化列表{ //其他初始化 } 多继承时构造函数定义如下： 派生类名：：派生类名（参数表）：基类名1（基类1初始化参数表），
c++ primer plus 第16章string 类和标准模板库,string 类输入
最新发布
zhyjhacker的博客
07-14 1098
c++ primer plus 第16章string 类和标准模板库,string 类输入。
c++继承初始化列表
09-13
C++中，继承的初始化列表是在派生类的构造函数中调用基类的构造函数的一种方式。通过使用初始化列表，我们可以指定派生类对象的基类子对象的初始化方式。 下面是一个示例代码，演示了如何在派生类的构造函数中使用初始化列表来调用基类的构造函数： ```cpp #include <iostream> class Base { public: Base(int value) { std::cout << "Base constructor called with value: " << value << std::endl; } }; class Derived : public Base { public: Derived(int value) : Base(value) { std::cout << "Derived constructor called with value: " << value << std::endl; } }; int main() { Derived d(42); return 0; } ``` 在上述代码中，`Derived` 是一个派生类，它继承自 `Base` 基类。在 `Derived` 类的构造函数中，我们通过初始化列表 `: Base(value)` 来调用基类 `Base` 的构造函数，并将参数 `value` 传递给基类构造函数进行初始化。 当我们运行上述代码时，输出结果为： ``` Base constructor called with value: 42 Derived constructor called with value: 42 ``` 可以看到，首先调用了基类 `Base` 的构造函数，然后再调用派生类 `Derived` 的构造函数。 通过使用继承的初始化列表，我们可以控制派生类对象以及其基类子对象的初始化过程。这样可以确保基类的构造函数在派生类的构造函数之前调用，从而保证正确的对象初始化顺序。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值