首页 > 编程语言 >C++——继承

C++——继承

时间：2024-10-19 23:18:02浏览次数：3  
标签：继承 子类 C++ Person int Student 父类 public

1.概念

继承(inheritance)机制是面向对象程序设计 使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称 派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是 函数复用，把公共的部分单独写成一个函数，让程序去调用这个函数；而继承的本质可以认为是 类设计层次的复用。

面向对象三大特性：封装、继承和多态。有时还会加上抽象。

2.示例

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}
protected:
	string _name = "peter"; // 姓名
	int _age = 18; //年龄
};


继承上面的类：  : + 类名 ，public是一种继承方式
class Student : public Person
{
protected:
	int _stuid; // 学号
};

class Teacher : public Person
{
protected:
	int _jobid; // 工号
};

int main()
{
	Student s;
	Teacher t;

	s.Print();
	t.Print();

	return 0;
}

3.定义

3.1定义格式

上述代码中，Person就是父类，也称作基类。Student是子类，也称作派生类。

3.2继承关系和访问限定符

3.3继承基类成员访问方式的变化

类成员  \  继承方式 public继承 protected继承 private继承
基类的public成员 派生类的public成员 派生类的protected成员 派生类的private成员
基类的protected 成员 派生类的protected成员 派生类的protected成员 派生类的private成员
基类的private成 员 在派生类中不可见 在派生类中不可见 在派生类中不可见

3.3.1总结

一、

基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在子类里面还是子类外面都不能去访问它。所以父类的一些成员，如果不想要给子类使用，就可以设置为私有，但实际上父类成员也很少定义为私有，因为这样就不符合复用的规则了。

二、 基类的protected成员被继承下来后， 在子类里面可以访问，在子类外面不可以访问。 基类private成员在派生类中是 不能被访问，如果基类成员 不想在类外直接被访问，但需要在派生类中能访问，就定义为 protected。由此也可以看出 保护成员限定符是 因继承才出现并有意义的。 三、 观察上面的表格，我们进行总结会发现， 基类的私有成员在子类都是不可见的。而基类其它成员在子类的 访问方式 = Min(成员在基类的访问限定符，继承方式)，取权限小的那个， 已知：public > protected > private。 四、 使用 关键字class时 默认的继承方式是private，使用 struct时默认的继承方式是 public，不过 最好还是显式地写出继承方式。 
class Student : Person//默认是私有继承
{
protected:
	int _stuid;
};

struct Student : Person//默认是公有继承
{
protected:
	int _stuid;
};

五、 在实际运用中一般使用都是 public继承，几乎很少使用 protetced/private继承，也不提倡使用 protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，不符合复用，实际中扩展维护性不强。

4.基类和派生类间的对象赋值转换

4.1引入

已知，不同类型的对象在赋值时，如果是相近类型，即意义相似的类型时，可以隐式类型转换

隐式类型转换要产生临时变量

int main()
{
	double d = 3.14;
	int i = d;
	//这就是相近类型，都是表示数据大小
	//只是说一个是int类型、不带精度，一个是double类型、带有精度

	//int& r = d;//这里报错不是因为类型不匹配
	//而是因为r引用的不是d，是中间生成的临时变量，但临时变量具有常性

	const int& r = d;//所以要加上const

	//int和int*也是相近类型，int表示数据大小，int*是地址，地址本质是一个编号

	return 0;
}

4.2父子类的赋值兼容规则

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

class Student : public Person
{
public:
	int _No; // 学号
};

int main()
{
	Student s;
	Person p = s;
	//父类和子类，在public继承的情况下，它们是一个is-a的关系
	//即子类对象就是一个特殊的父类对象
	//所以按照之前的理解，这里也应该会产生临时对象

	Person& rp = s;
	//但这里却没有报错，也就是说没有产生临时对象，这是为什么？
	//难道自定义类型的临时对象没有常性吗？


///
	string str = "hello";
	//这里也是隐式类型的转换，单参数的构造函数支持隐式类型转换
	//先构造，再拷贝构造

	//string& rstr = "hello";
	//但实际上，自定义类型的临时对象也是有常性的
	const string& rstr = "hello";

	return 0;
}

那么   Person& rp = s;   这里为什么不会报错呢？

其实这里是一个特殊处理，它并不产生临时对象。

5.继承中的作用域

5.1引入

//命名空间定义的是一个域，类定义的也是一个域
class Person
{
protected:
	string _name = "小李子"; 
	int _num = 111; 
};

class Student : public Person
{
public:
	void Print()
	{
	}
protected:
	int _num = 999; 

	//父类中已经有了一个叫_num的变量
	//那子类这里还可以定义名为_num的变量吗？

	//答案是可以的，父类和子类各自拥有独立的作用域
	//在同一个作用域中，是不能定义同名变量的
	//但它们是属于不同的域

	//所以，父类的_num虽然是继承下来了
	//但还是认为父类和子类各有一个_num成员
};

5.2新的问题

class Person
{
protected:
	string _name = "小李子"; 
	int _num = 111; 
};

class Student : public Person
{
public:
	void Print()
	{
        cout << " 学号:" << _num << endl;
        //这里访问的是哪个类的_num？

        //显然是子类的。
        //访问时要去查找_num，遵循就近原则


		cout << " 身份证号:" << Person::_num << endl;
		//这样去显式地指定作用域，就可以访问父类的_num了
	}
protected:
	int _num = 999; 

};

5.3新概念：隐藏

父类和子类可以有同名成员，因为他们是独立作用域

默认情况下，直接访问的是子类的成员，子类的同名成员隐藏(重定义)了父类同名成员

5.3.1练习

// A:两个fun构成函数重载
// B:两个fun构成隐藏
// C:编译报错
// D:运行报错
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};

class B : public A
{
public:
	void fun(int i)
	{
		cout << "func(int i)->" << i << endl;
	}
};

void Test()
{
	B b;
	b.fun(10);
};

int main()
{
	Test();
	//答案是B，函数重载要求在同一作用域
	//就比如STL中，不同容器的同名函数，是不会报错的
	return 0;
}

注意：在继承中，同名的成员函数，函数名相同就构成隐藏，与参数、返回值无关。

void Test()
{
	B b;
	b.fun(10);

	//b.fun();
    //注意：这样是调用不到父类的fun函数的
    //子类的函数隐藏了父类的，这样调用就会去调用子类的
    //而子类的是带参的，会认为忘记传了参数，然后报错

    b.A::fun();
    //指定作用域就可以调用父类的函数了
};

总结：建议尽量不要去写同名成员

6.派生类的成员函数

6.1默认构造函数

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:

	int _id; 
};

int main()
{
	Student s;
    //Student不写构造、析构函数时，
    //默认生成的构造、析构函数会去自动调用父类的构造、析构函数

	return 0;
}

6.2显式书写的构造函数

错误写法：

class Student : public Person
{
public:
	Student(const char* name,int id)
		:Person(name)//要像调用匿名对象时一样去调用
		,_id(id)
	{}

	int _id; 
};

int main()
{
	Student s("jx",198);
	//显式写构造函数时，不能像之前的类那样去初始化
	//C++有规定，派生类的构造函数
	//要分成两个部分来看待
	//要初始化父类的成员，就要把父类当成一个完整的对象去初始化
	//而不是单个成员依次去初始化
	//所以要去复用父类的成员函数

	//规定：要去初始化父类成员，就要去显式调用父类的构造函数
	
	//日常情况下，构造函数除了定位new是不能显式调用的

	return 0;
}

6.3默认的拷贝构造

class Student : public Person
{
public:
	int _id; 
};

int main()
{
	Student s("jx",198);
    Student s1(s);
	//拷贝构造同理，不显式写拷贝构造时
    //Student的默认拷贝构造会去调用父类的拷贝构造

	return 0;
}

可以认为现在将成员分为了内置类型、自定义类型和父类成员
内置类型进行值拷贝，自定义类型调用自己的函数，父类去调用父类的函数

6.4显式书写的拷贝构造

class Student : public Person
{
public:
	Student(const char* name,int id)
		:Person(name)
		,_id(id)
	{
		cout << "Student(const char* name,int id)" << endl;
	}

	//Student(const Student& s)//此时会去调用父类的构造函数而非拷贝构造
	//{
	//	cout << "Student(const Student& s)" << endl;
	//}

	Student(const Student& s)//此时才会调用父类的拷贝构造
		:Person(s)//父类的拷贝构造，要传父类的对象
		//如何把子类对象s中父类的部分拿出来？

		//由父子类的赋值兼容规则可知，直接传s就可以

		,_id(s._id)
	{
		cout << "Student(const Student& s)" << endl;
	}

	int _id;
};

int main()
{
	Student s("jx",198);
    Student s1(s);


	return 0;
}

6.5默认赋值重载

class Student : public Person
{
public:
	int _id; 
};

int main()
{
	Student s("jx",198);
    Student s1(s);

	Student s2("lx", 200);
	s = s2;
	//赋值重载同理，不显式写赋值重载时
    //Student的默认赋值重载会去调用父类的赋值重载

	return 0;
}

6.6显式书写的赋值重载

class Student : public Person
{
public:

	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			//注意要指定类域，否则会死循环导致栈溢出
			_id = s._id;
		}

		cout << "Student& operator=(const Student& s)" << endl;
		return *this;
	}

	int _id; 
};

int main()
{
	Student s("jx",198);
    Student s1(s);

	Student s2("lx", 200);
	s = s2;


	return 0;
}

6.7显式书写的析构函数

class Student : public Person
{
public:

	~Student()
	{
		//~Person();//析构函数不能这样显式调用
		//这里是特例，~Student()和父类的~Person()构成了隐藏关系

		// 由于多态的原因，析构函数会被统一处理成destructor
	    // 所以父子类的析构函数构成隐藏关系

		Person::~Person();
		//想要访问，就需要指定类域

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

	int _id; 
};

int main()
{
	Student s("jx",198);

	Student s2("lx", 200);
	s = s2;

	return 0;
}

原因：

6.7.1正确写法

class Student : public Person
{
public:

	~Student()
	{
		//Person::~Person();
		cout << "~Student()" << endl;
	}
//之前的写法没有报错是因为没有对资源进行释放，
//否则会多调用两次析构函数，就会出问题

	int _id; 
};

int main()
{
	Student s("jx",198);

	Student s2("lx", 200);
	s = s2;

	return 0;
}

标签：继承,子类,C++,Person,int,Student,父类,public
From： https://blog.csdn.net/2301_80342122/article/details/142956935

相关文章

  • 图-C++基础
    图论是计算机科学和数学中非常重要的一个分支，涉及到图的性质、结构以及相关的算法。以下是对图论的基础知识、常用算法及其相关代码的整理，帮助你为CSP备考做好准备。一、图的基本概念1.1图的定义在数学中，图是一个由顶点（或节点）和边组成的集合。图可用以下形式表示：无向图：边......
  • 【C++】原地逆置单链表（不开辟新的储存空间）
    首先看图例：创建一个单链表L，并用指针p指向需要逆置的第一个结点，s指向p的下一个。（这里s的作用是为了防止p后的结点丢失） 第一个结点逆置后成为最后一个，所以其后为NULL，即p->next=NULL（其他结点正常头插）用s指向了的p之后的结点，所以它们不会丢失。第一个结点接上后，p、s重新指向......
  • 【信奥赛·C++基础语法】CSP-J C++ STL 标准模板库 - 算法
    序言标准模板库（STL）的算法部分提供了一系列强大的工具，用于对各种容器中的数据进行操作。这些算法可以大大提高编程效率，减少代码重复，使程序更加简洁、高效和可读。无论是处理简单的数据结构还是复杂的大规模数据，STL算法都能发挥重要作用。一、STL算法的分类排序算法快速......
  • （新！）c++多态
    C++ 多态多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，就会用到多态。C++多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。下面的实例中，基类Shape被派生为两个类，如下所示：实例#include<iostream>usingnames......
  • 洛谷知识点——C++ 11 实现一次性输出多行文本
    完整语法是R"deli(...)deli"。（其中deli并不是固定的，那里其实是一个用户自定义的字符序列，最多16个基本字符，不可含反斜线，空格和小括号。）故P1000超级玛丽游戏解法为#include<iostream>usingnamespacestd;intmain(){cout<<R"(********......
  • C++基础
    1、注释单行注释：//这是注释多行注释：/*这是注释*/2、变量 数据类型变量名=变量初始值； 3、常量宏常量：通常在文件开头定义#define常量名常量值const修饰的静态变量，表示一个常量，不可修改。const数据类型常量名=常量值#include<iostream>usingna......
  • 「图::连通」详解并查集并实现对应的功能 / 手撕数据结构（C++）
    目录概述成员变量创建销毁根节点访问路径压缩启发式合并复杂度Code概述并查集，故名思议，能合并、能查询的集合,在图的连通性问题和许多算法优化上着广泛的使用。这是一个什么数据结构呢？一般来讲，并查集是由一系列集合组成的集合群。其中，每个集合都有一个根节点，它的......
  • 学习记录，这该死的c++
    最近还是比较懈怠，除了老师布置的作业其他的也是匆匆过一眼至于代码方面最主要的问题还是不理解该怎么表达。总的来说还是要在多沉淀。为什么会有知道敲代码但是不知道该怎么成功表达这个问题啊？还是不能把代码敲得精简一些可以来个人教我怎么敲关系符号吗？运用的还不是很熟练......
  • 【C++贪心】2086. 喂食仓鼠的最小食物桶数|1622
    本文涉及知识点C++贪心LeetCode2086.喂食仓鼠的最小食物桶数给你一个下标从0开始的字符串hamsters，其中hamsters[i]要么是：‘H’表示有一个仓鼠在下标i，或者’.’表示下标i是空的。你将要在空的位置上添加一定数量的食物桶来喂养仓鼠。如果仓鼠的左边或右边......
  • 南沙C++信奥赛陈老师解一本通题 1286：怪盗基德的滑翔翼
    ​【题目描述】怪盗基德是一个充满传奇色彩的怪盗，专门以珠宝为目标的超级盗窃犯。而他最为突出的地方，就是他每次都能逃脱中村警部的重重围堵，而这也很大程度上是多亏了他随身携带的便于操作的滑翔翼。有一天，怪盗基德像往常一样偷走了一颗珍贵的钻石，不料却被柯南小朋友识破了伪......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99