C++15 ---继承2：重载与覆盖、隐藏、拷贝构造函数、赋值运算符重载、静态数据成员

已于 2023-03-01 21:09:02 修改
阅读量567 收藏 2
点赞数
分类专栏： C++学习笔记 笔记 文章标签： c++ c语言 算法
于 2022-11-16 17:29:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kyrie_sakura/article/details/127868597
版权
本文详细介绍了C++中的继承特性，包括函数的重载、覆盖和隐藏。重载关注同名函数的参数列表不同，覆盖涉及派生类对基类函数的替换，而隐藏则是派生类同名同参函数对基类函数的屏蔽。文章通过示例代码阐述了这些概念，并特别讨论了构造函数在有无参、指针成员时的注意事项，强调了正确初始化指针成员的重要性。此外，还提到了拷贝构造函数和赋值运算符在继承中的应用，以及静态数据成员在继承类中的共享特点。
摘要由CSDN通过智能技术生成

一、重载与覆盖的特征

1、重载

函数名相同，函数参数列表不同，和返回值无关，和const有关
成员函数被重载的特征:
(1）相同的范围（在同一个类中)；
(2）函数名字相同；
(3）参数不同；
(4） virtual关键字可有可无。

2、覆盖

覆盖是指派生类函数覆盖基类函数，特征是:
(1）不同的范围（分别位于派生类与基类)；
(2）函数名字相同；
(3）参数相同；
(4）基类函数必须有virtual关键字。

二、隐藏

派生类的成员函数和基类的函数同名同参，则将基类的函数隐藏。

这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下:

(1）如果派生类的函数与基类的函数同名，但是参数不同。
此时，不论有无 virtual关键字，基类的函数将被隐藏（注意别与重载混淆)。
(2)如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。
此时，基类的函数被隐藏（注意别与覆盖混淆)。

1、继承关系的类
2、父子类的同名同参函数不能为虚

示例代码1：

class A
{
public:
	void print() { cout << "A::print" << endl; }
};
/*
隐藏：派生类的成员函数和基类的函数同名同参，则将基类的函数隐藏
*/
class B :public A
{
public:
	//print将派生下来的A的print隐藏了
	void print() 
	{
		cout << "B::print" << endl; 
	}
};
void main()
{
	A a;
	B b;
	a.print();
	b.print();

}

运行结果：

在这里插入图片描述

示例代码2：

class A
{
public:
	void print() { cout << "A::print" << endl; }
protected:
	int m_i;
};
/*
隐藏：派生类的成员函数和基类的函数同名同参，则将基类的函数隐藏
*/
class B :public A
{
public:
	//print将派生下来的A的print隐藏了
	void print() 
	{
		cout << "B::print" << endl; 
		cout << m_i << " " << A::m_i << endl;
	}
	void set() { m_i = 10; A::m_i = 20; }
protected:
	int m_i;
};
void main()
{
	A a;
	B b;
	a.print();
	b.set();
	b.A::print();
	b.print();
	cout << sizeof(B) << endl;
}

运行结果：

在这里插入图片描述

三、继承的有参无参构造函数注意点-有无参构造，并且有指针数据成员。

对于以下代码，无法正常实现

class Person
{
public:
	Person(){cout << "Person()" <<endl;}
	Person(const char *name,char sex,int age):m_sex(sex),m_age(age)
	{
		m_name = new char[strlen(name) + 1];
		strcpy_s(m_name,strlen(name) +1,name);
	}
	void print()
	{
		cout << m_name <<" "<< m_sex <<" "<< m_age <<" ";
	}
private:
	char *m_name;
	char m_sex;
	int m_age;
};

class Student:public Person
{
public:
	Student(){cout << "Student()" <<endl;}
	Student(int num,const char *name,char sex,int age,int score):Person(name,sex,age),m_num(num),m_score(score){}
	void print()
	{
		cout << m_num << " ";
		Person::print();
		cout << m_score << endl;
	}
private:
	int m_num;
	int m_score;
};

void main()
{
	Student s;
	Student s1(1001,"yasuo",'f',21);

	s.print();//error,出错点
	s1.print();
	
}

在这里插入图片描述

理解：

Person类和Student类的内存布局：
在这里插入图片描述
而主程序定义了无参对象s和有参对象s1.
而无参对象s，构造时，没能为其中的指针char *m_name;开辟空间，
就例如下述代码：

void main()
{
	int *p;
	cout << p << endl;//erroe,其没有指向合法的内存空间
}

解决方法：

有无参构造，并且有指针数据成员。需要在无参构造函数里为其开辟空间，一个空间作为占位符。

class Person
{
public:
	//Person():m_sex('f'),m_age(20)
	Person()
	{
		m_name = new char[1];
		*m_name = '\0';
	}
	Person(const char *name,char sex,int age):m_sex(sex),m_age(age)
	{
		m_name = new char[strlen(name) + 1];
		strcpy_s(m_name,strlen(name) +1,name);
	}
	~Person()
	{
		if(m_name != NULL)
		{
			delete[]m_name;
			m_name = NULL;
		}
	}
private:
	char *m_name;
	char m_sex;
	int m_age;
};

在这里插入图片描述

四、继承的拷贝构造函数、赋值运算符重载使用：

示例代码：

class Person
{
public:
	Person():m_sex('f'),m_age(20)
	{ 
		m_name = new char[1];
		*m_name = '\0';
		cout << "Person()" << endl; 
	}
	Person(const char* name, char sex, int age):m_sex(sex),m_age(age)
	{
		m_name = new char[strlen(name) + 1];
		strcpy_s(m_name, strlen(name) + 1, name);
	}
	Person(Person& p) :m_sex(p.m_sex), m_age(p.m_age)//拷贝构造函数
	{
		m_name = new char[strlen(p.m_name) + 1];
		strcpy_s(m_name, strlen(p.m_name) + 1, p.m_name);
	}
	Person& operator=(Person& p)//赋值运算符重载
	{
		if (this == &p)
			return *this;
		delete[]m_name;
		m_name = new char[strlen(p.m_name) + 1];
		strcpy_s(m_name, strlen(p.m_name) + 1, p.m_name);
		
		m_sex = p.m_sex;
		m_age = p.m_age;
		return *this;
	}
	void print()
	{
		cout << m_name << " " << m_sex << " " << m_age << " ";
	}
	~Person()
	{
		if (m_name != NULL)
		{
			delete[]m_name;
			m_name = NULL;
		}
	}
private:
	char* m_name;
	char m_sex;
	int m_age;
};
class Student :public Person
{
public:
	Student():m_num(0),m_score(0) { cout << "Student()" << endl; }
	Student(int num, const char* name, char sex, int age, int score):m_num(num),Person(name,sex,age),m_score(score) {}
	void print()
	{
		cout << m_num << " ";
		Person::print();
		cout << m_score << endl;
	}
	Student(Student& s) :Person(s), m_num(s.m_num), m_score(s.m_score) {}//拷贝构造函数
	Student& operator=(Student& s)//赋值运算符重载
	{
		if (this == &s)
			return *this;
		Person::operator=(s);
		m_num = s.m_num;
		m_score = s.m_score;
		return *this;
	}
private:
	int m_num;
	int m_score;
};

void main()
{
	Student s;
	Student s1(1001, "zhangsan", 'f', 20, 78);
	s.print();
	s1.print();
	Student s2(s1);//调用拷贝构造函数
	s2.print();
	s = s1;//调用赋值运算符重载
	s.print();
}

运行结果：

在这里插入图片描述

五、继承情况下静态数据成员的使用

基类继承后，子类也有对静态数据成员的使用权，是共享的。
但不占类内空间。

示例代码：

class Person
{
public:
	Person(int num = 1000) :m_num(num) {}
	void print()
	{
		cout << "count = " << m_count << endl;
	}
protected:
	int m_num;
	static int m_count;//静态数据成员
};

int Person::m_count;//外部二次声明，对该静态成员进行初始化

//三个继承类：
class Student :public Person
{
public:
	Student(int num, const char* job) :Person(num)
	{
		m_job = new char[strlen(job) + 1];
		strcpy_s(m_job, strlen(job) + 1, job);
		m_count++;
	}
private:
	char* m_job;
};
class Teacher :public Person
{
public:
	Teacher(int num,const char*job):Person(num) 
	{
		m_job = new char[strlen(job) + 1];
		strcpy_s(m_job, strlen(job) + 1, job);
		m_count++;
	}
private:
	char* m_job;
};
class Worker :public Person
{
public:
	Worker(int num,const char*job) :Person(num)
	{
		m_job = new char[strlen(job) + 1];
		strcpy_s(m_job, strlen(job) + 1, job);
		m_count++;
	}
private:
	char* m_job;
};
void main()
{
	Student s(1001, "student");
	Teacher t(1002, "teacher");
	Worker w(1003, "worker");
	w.print();
	t.print();
	s.print();
	Worker w1(1006, "worker");
	s.print();
	cout << sizeof(Worker) << endl;//为8字节，静态数据成员不占类的内存单元
}

运行结果：

在这里插入图片描述

kyrie_sakura
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ || 继承 覆盖 重载
LQEmptycity的博客
11-13 1347
文章目录类与类之间的关系继承隐藏动多态覆盖 甚麽样的函数会出现重载 甚麽样的函数会出现隐藏 甚麽样的函数会出现覆盖 覆盖的函数之间会不会存在隐藏关系 覆盖关系基于隐藏关系 覆盖一定有隐藏 虚函数表的产生 动多态的调用过程 类与类之间的关系 组合 嵌套 — 一个类中声明了另一个类 一个类是另一个类的一部分 代理 — 一个类的接口是另一个类接口的子集 一个类的功能是需要依赖另一个类的功能实现 继承 继承 — 父类：基类 子类：派生类 子类无法访问父类的私有成员 继承权限：public prot
构造函数，重载，重写，继承
weixin_34364071的博客
05-10 325
一、构造函数 1.无参： 构造函数的名字和类的名字相同。 （）里面不写形式参数，{}里面写逻辑代码，对类进行初始化 2.有参： （）里面写形式参数，{}里面写逻辑代码，例：this.+代码，对类进行初始化 二、重载 方法名(返回值后面的是名字),返回值相同(void无返回值不用写return)， public void asfhuuh(){ } public void asfhuuh(int ...
Java继承 重载方法_Java继承(方法覆盖和重载)
weixin_35223575的博客
02-27 133
除了Java继承是该语言的基本特征之外,我还有一些问题.以下是我的测试示例的来源：class MyClass{public void say(String t){System.out.println("Hello MyClass "+t);}public void print(MyClass t){System.out.println("MyClass is printed");}public v...
C++学习笔记day47-----C++98-继承中的构造函数，析构函数，拷贝构造函数，拷贝赋值函数，多重继承，虚继承
displayMessage的博客
06-05 492
继承中的构造函数，析构函数，拷贝构造函数，拷贝赋值函数，多重继承，虚继承
继承中的重载以及构造函数与虚函数
everysmile的专栏
07-30 1085
1，继承中的重载当子类与父类有同名而不同参数的函数时，　并不能直接构成函数的重载，而是子类的函数隐藏了父类函数的可视性，因为虽然子类可以调用父类的函数，但是他们不是在同一个域中，函数的重载的前提是多个函数在同一个域中由参数的不同而构成的重载。所以解决方法是在子类中，通过using Basename:function的申明方式来解决。2，构造函数的生成问题当定义一个类没有显式的定义一个与
C++中的四个默认成员函数与运算符重载详解
08-29
四个默认成员函数包括构造函数、析构函数、拷贝构造函数和赋值运算符重载函数，这些函数是类的成员函数，用于定义类对象的创建、销毁、复制和赋值等操作。 1. 构造函数：构造函数是特殊的成员函数，用于初始化类...
C++中复制构造函数和重载赋值操作符总结
09-04
C++中的复制构造函数和重载赋值操作符是编程中至关重要的概念，尤其是在处理对象的复制和赋值时。这两个特殊成员函数确保了对象之间的数据安全和正确性。 复制构造函数是一种特殊的构造函数，其任务是初始化一个新...
解析C++中不能重载为友元函数的四个运算符
12-26
现在先说说赋值运算符“=”的重载C++规定赋值运算符“=”只能重载为类的非静态成员函数，而不可以重载为类的友元函数。不能重载为类的静态成员应该比较容易理解，因为静态成员函数是属于整个类的，不是属于某个对象...
详解C++中的函数调用和下标以及成员访问运算符的重载
09-02
在C++编程语言中，运算符重载是一项强大的特性，允许程序员为已有的运算符赋予新的含义，以适应特定的数据类型或类的行为。本篇主要探讨了三个关键的运算符重载：函数调用运算符、下标运算符和成员访问运算符。 1. ...
C++继承中的重载、隐藏、覆盖
最新发布
坚持学习
03-28 253
C++继承中的重载、隐藏、覆盖
继承 、重载、覆盖的概念及其用法
xunao1992的博客
10-27 770
一:继承 1.继承的概念: 是对现有的类加以利用，并为其添加新功能的一种有效途径。通过继承来重复使用原有的代码（再生）， 一般需要保持“基础类”不变，只是将这儿或哪儿的东西串联起来，以达到预期的效果，然而，继承并不是在现有类基础上制造新类的唯一方法。 通过“合成”，即可将一个对象嵌入新类。 建一个A类: class A{ //成员变量 其中num是实参 int num=0; //成员方法,其中 ...
继承、重载和覆盖的区别
Wpan的博客
06-19 7039
主要介绍了继承、重载和覆盖的区别
继承，重载，覆盖联系及区别
weixin_43823656的博客
01-15 653
相信很多同学和我一样，在刚开始接触Java中的这些重要特点的时候，对于他们的含义以及区别总是搞不清楚，今天就来和我一起看看继承，重载，覆盖，这几个概念的联系还有区别。 继承 继承是面向对象技术中的一个重要特点，在Java中，继承是单一继承的，即一个类只能拥有一个父类。使用extends关键字。那么如何让Java有多继承的特性呢，我们用implements关键字实现，这是继承中一个重要的点——接口。...
c++ 继承 虚函数与多态性 重载 覆盖 隐藏
陆郎
09-27 2162
2011.9.27  1) 定义一个对象时，就调用了构造函数。如果一个类中没有定义任何构造函数，那么C++编译器就会在某种情况下为该类提供一个默认的不带参数的构造函数。 只要一个类中定义了一个构造函数，不管这个构造函数是不是默认的，C++编译器都不会再提
C++类四大隐藏函数详解(构造函数、析构函数、拷贝构造、赋值函数)
weixin_51420051的博客
01-11 1010
构造函数传送门 一、析构函数 1、什么是析构函数 ​ 与构造函数一样也是一种特殊的成员函数，它会在对象释放的时候自动调用，负责一些收尾工作，如：保存数据、释放资源等。 2、函数格式 ~类名(void) { } 3、析构函数的任务 ​ 负责释放在构造函数中获取到的所有资源。 ​ 执行过程： ​ 1、先执行析构函数本身代码 ​ 2、调用成员变量的析构函数 ​ 3、调用父类的析构函数 注意：析构函数与构造函数的执行顺序刚好相反 #include <iostre
覆盖和隐藏
baoendemao的专栏
11-20 655
1.先来总结java中方法的覆盖和隐藏 一个大的原则：静态方法不能被覆盖。实例方法被覆盖，静态方法被隐藏。被覆盖的方法只有覆盖它们的类才能访问它们，而访问被隐藏的方法是提供该方法的全局名。 例子： 01: class Super 02: { 03: static String greeting() 04: { 05: return "Goodnight"; 06: } 0
覆盖与隐藏
瞎子my的博客
06-01 593
题目链接： https://www.nowcoder.com/questionTerminal/f29ec891b0284259a922d0dae964ef3a 来源：牛客网 下面程序的输出是（） class A { public: void foo() { printf("1"); } virtual void...
c++ 重载 覆盖 隐藏
TuxedoLinux的博客
01-09 524
c++
C++覆盖和隐藏的区别
zhongzi123456789的专栏
03-14 1061
覆盖： 派生类和基类的函数名和参数都一样，并且基类有virtual关键字是 覆盖 隐藏： 基本规则：     1) 如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏。     2) 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏。
C++运算符重载：成员函数与友元函数的应用
本文将深入探讨C++编程中的运算符重载技术，以及它与一般成员函数之间的比较。运算符重载允许我们为已有的运算符赋予新的含义，使其能够适用于特定类的对象，从而实现更加直观和简洁的代码。 在C++中，运算符重载是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值