C++ 类与对象 面向对象编程 继承

最新推荐文章于 2024-06-18 20:12:34 发布
最新推荐文章于 2024-06-18 20:12:34 发布
阅读量750 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S_CuRrY666/article/details/122706700
版权

https://www.bilibili.com/video/BV1et411b73Z?p=127icon-default.png?t=M0H8https://www.bilibili.com/video/BV1et411b73Z?p=127

继承是面向对象三大特性之一

我们发现，定义一些类时，下级别的成员除了拥有上一级的共性，还有自己的特性

这个时候我们就考虑运用继承的技术，减少重复代码

1.继承的基本语法

普通实现

//JAVA页面
class Java
{
public:
	void header()
	{
		cout << "首页  公开课  登录  注册  。。。 公共头部" << endl;

	}

	void footer()
	{
		cout << "帮助中心  交流合作  站内地图  。。。 公共底部" << endl;
	}

	void left()
	{
		cout << "Java   Python   C++  公共分类列表" << endl;
	}

	void content()
	{
		cout << "Java 学科视频" << endl;
	}




};

class Python
{
public:
	void header()
	{
		cout << "首页  公开课  登录  注册  。。。 公共头部" << endl;

	}

	void footer()
	{
		cout << "帮助中心  交流合作  站内地图  。。。 公共底部" << endl;
	}

	void left()
	{
		cout << "Java   Python   C++  公共分类列表" << endl;
	}

	void content()
	{
		cout << "Python 学科视频" << endl;
	}


};

class CPP
{
public:
	void header()
	{
		cout << "首页  公开课  登录  注册  。。。 公共头部" << endl;

	}

	void footer()
	{
		cout << "帮助中心  交流合作  站内地图  。。。 公共底部" << endl;
	}

	void left()
	{
		cout << "Java   Python   C++  公共分类列表" << endl;
	}

	void content()
	{
		cout << "C++ 学科视频" << endl;
	}


};

继承实现

//公共页面类
class Basepage
{

public:
	void header()
	{
		cout << "首页  公开课  登录  注册  。。。 公共头部" << endl;

	}

	void footer()
	{
		cout << "帮助中心  交流合作  站内地图  。。。 公共底部" << endl;
	}

	void left()
	{
		cout << "Java   Python   C++  公共分类列表" << endl;
	}

	void content()
	{
		cout << "Java 学科视频" << endl;
	}
};

//Java
class Java :public Basepage
{
public:
	void content()
	{
		cout << "Java 学科视频" << endl;
	}
};

//Python 
class Python :public Basepage
{
public:
	void content()
	{
		cout << "Python 学科视频" << endl;
	}
};

//C++
class CPP :public Basepage
{
public:
	void content()
	{
		cout << "C++ 学科视频" << endl;
	}
};


void test01()
{
	cout << "Java 下载视频页面如下：" << endl;

	Java ja;
	ja.header();
	ja.content();
	ja.left();
	ja.footer();

	cout << "------------------------------" << endl;
	cout << "Python 下载视频页面如下：" << endl;

	Python py;
	py.header();
	py.content();
	py.left();
	py.footer();

	cout << "------------------------------" << endl;
	cout << "C++ 下载视频页面如下：" << endl;

	CPP cpp;
	cpp.header();
	cpp.content();
	cpp.left();
	cpp.footer();
}

int main()
{

	test01();


	return 0;

}

2.继承方式

继承的语法：  class 子类 ：继承方式  父类

继承方式一共有三种：

公共继承

保护继承

私有继承

#include <iostream>

using namespace std;

//继承方式
//公有继承
//保护继承
//私有继承

class Base1
{
public:
	int m_A;

protected:
	int m_B;

private:
	int m_C;
};

class Son1 :public Base1
{
public:

	void func()
	{
		m_A;//父类中的公共权限成员  到子类中依然是公共权限

		m_B;//父类中的保护权限成员  到子类中依然是保护权限

		//m_C;父类中的私有权限成员  子类中访问不到

	}
};

//保护继承
void test01()
{
	Son1 s1;
	s1.m_A = 100;
	//s1.m_B = 100;  到 Son 中m_B 是保护权限  类外访问不到
}

//保护继承
class Base2
{
public:
	int m_A;

protected:
	int m_B;

private:
	int m_C;
};

class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 100;//父类中的公共成员  到子类中变为保护权限
		m_B = 100;//父类中的保护成员  到子类中变为保护权限
		//m_C = 100; 子类访问不到
	}
};

void test01()
{
	Son2 s1;
	//s1.m_A = 1000;  Son2 中 m_A变为保护权限  因此类外访问不到
	//s1.m_B = 1000;  Son2 中 m_B变为保护权限  因此类外访问不到


}

//私有继承
class Base3
{
public:
	int m_A;

protected:
	int m_B;

private:
	int m_C;

};

class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 1000;   //父类中的公共成员  到子类中变为  私有成员
		m_B = 10000;  //父类中的保护成员  到子类中变为  私有成员
		//m_C = 100000;  父类中的私有权限  子类中访问不到

	}
};

class GrandSon3 :public Son3
{
public:
	void func()
	{
		/*m_A = 1000;
		m_B = 2000;      到了Son3 中 m_A变为私有  即使是儿子也访问不到
		m_C = 3000;*/
	}
};

void test03()
{
	Son3 s1;
	/*s1.m_A = 100;
	s1.m_B = 10;      到Son3 中变为私有成员  类外访问不到
	s1.m_C = 1;*/

}

3.继承中的对象模型

利用开发人员命令提示工具查看对象模型

1.跳转盘符 F:

2.跳转文件路径 cd 具体路径

3.查看命令：dir  目录

cl /d1 reportSingleClassLayout类名 文件名

#include <iostream>

using namespace std;

//继承中的对象模型

class Base
{
public:
	int m_A;
	 
protected:
	int m_B;

private:
	int m_C;

};

class Son :public Base
{
public:
	int m_D;
};

//利用开发人员命令提示工具查看对象模型  deve
//跳转盘符 F:
//跳转文件路径  cd  具体路径如下
//查看命名
// c1 /d1 reportSingleClassLayout类名 文件名

void test01()
{
	//父类中所有的非静态成员属性都会被子类继承
	//父类中私有成员属性 是被编译器给隐藏了 因此是访问不到，但却是被继承下去了

	cout << "size of Son = " << sizeof(Son) << endl;//结果是16
}

int main()
{
	test01();


	return 0;
}

4.构造和析构顺序

继承中的构造和析构顺序如下:

先构造父类，再构造子类，析构的顺序与之相反

#include <iostream>

using namespace std;

//继承中的构造与析构顺序

class Base
{
public:
	Base()
	{
		cout << "Base 构造函数!" << endl;
	}

	~Base()
	{
		cout << "Base 析构函数!" << endl;
	}
};

class Son :public Base
{
public:
	Son()
	{
		cout << "Son 构造函数!" << endl;
	}

	~Son()
	{
		cout << "Son 析构函数!" << endl;
	}
};

void test01()
{
	//Base b;
	
	//继承中的构造和析构顺序如下
	//先构造父类，再构造子类，析构的顺序与构造的顺序相反
	//先进后出

	Son s;

}

int main()
{
	test01();

	cout << "666" << endl;

	return 0;
}

5.同名成员处理

访问子类同名成员，直接访问即可
访问父类同名成员，需要加作用域
 

#include <iostream>

using namespace std;

//·访问子类同名成员，直接访问即可
//·访问父类同名成员，需要加作用域

class Base
{
public:

	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base - func()" << endl;
	}

	void func(int a)
	{
		cout << "Base - func()" << endl;
	}

	int m_A;

};

class Son : public Base
{
public:

	Son()
	{
		m_A = 200;
	}

	void func()
	{
		cout << "Son - func()" << endl;
	}

	int m_A;
};

//同名属性处理方式
void test01()
{
	Son s;
	cout << "Son m_A = " << s.m_A << endl;

	//如果通过子类对象  访问到父类中同名成员  需要加作用域
	cout << "Base m_A = " << s.Base::m_A << endl;


}

//同名函数处理方式
void test02()
{
	Son s;

	s.func();//直接调用  调用是子类中的同名成员

	//如何调用到父类中的同名成员函数？
	s.Base::func();

	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有的同名成员函数
	//如果想访问到父类中被隐藏的同名成员函数，需要加作用域
	s.Base::func(100);

}

int main()
{
	//test01();
	test02();

	return 0;
}

6.同名静态成员处理

静态成员和非静态成员出现同名，处理方式一致

访问子类同名成员，直接访问即可
访问父类同名成员，需要加作用域

#include <iostream>

using namespace std;

//静态成员和非静态成员出现同名，处理方式一致
//·访问子类同名函数  直接访问即可
//·访问父类同名成员  需要加作用域

class Base
{
public:

	static int m_A;

	static void func()
	{
		cout << "Base - static void func()" << endl;
	}


	static void func(int a)
	{
		cout << "Base - static void func()" << endl;
	}
};

int Base::m_A = 100;

class Son : public Base
{
public:
	static int m_A;

	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
};
int Son::m_A = 200;

//同名静态成员属性
void test01()
{
	//1、通过对象访问
	Son s;
	cout << "通过对象访问" << endl;
	cout << "Son m_A = " << s.m_A << endl;
	cout << "Base m_A = " << s.Base::m_A << endl;

	//2、通过类名访问
	cout << "通过类名访问" << endl;
	cout << "Son m_A = " << Son::m_A << endl;

	//第一个::代表通过类名方式访问  第二个::代表访问父类作用域下
	cout << "Base m_A = " << Son::Base::m_A << endl;

}

void test02()
{

	//1、通过对象访问
	cout << "通过对象访问" << endl;
	Son s;
	s.func();

	s.Base::func();

	//2、通过类名访问
	cout << "通过类名访问" << endl;
	Son::func();
	Son::Base::func();

	Son::Base::func(100);
}
 


int main()
{
	test01();

	test02();

	return 0;
}

7.多继承语法

C++允许一个类继承多个类

语法：class 子类：继承方式 父类1，继承方式 父类2

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

#include <iostream>

using namespace std;

//C++允许一个类继承多个类   多继承

class Base1
{
public:

	Base1()
	{
		m_A = 100;
	}

	int m_A;

};

class Base2
{
public:

	Base2()
	{
		m_A = 200;
	}

	int m_A;

};

//子类  需要继承Base1 和 Base2
class Son :public Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}

	int m_C;
	int m_D;
};

void test01()
{
	Son s;

	cout << "size of Son = " << sizeof(s) << endl;

	//当父类中出现同名成员  需要加作用域区分

	cout << "Base1::m_A = " << s.Base1::m_A << endl;
	cout << "Base2::m_A = " << s.Base2::m_A << endl;

}

int main()
{
	test01();

	return 0;
}

8.菱形继承问题

菱形继承概念：

        两个派生类继承同一个基类

        又有某个类同时继承着两个派生类

#include <iostream>

using namespace std;

//动物类
class Animal
{
public:
	int m_Age;

};

//羊类
class Sheep:public Animal{};

//驼类
class Camel:public Animal{};

//羊驼类
class Alpaca:public Sheep,public Camel
{
	

};

void test01()
{
	Alpaca a;

	a.Sheep::m_Age = 18;
	a.Camel::m_Age = 28;

	//当菱形继承  两个父类拥有相同的数据  需要加以作用域区分

	cout << "a.Sheep::m_Age = " << a.Sheep::m_Age << endl;
	cout << "a.Camel::m_Age = " << a.Camel::m_Age << endl;

	//这份数据我们知道  只要有一份就可以 菱形继承导致数据有两份 资源浪费


}

int main()
{
	test01();


	return 0;
}

 

大嘤三喵军团
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++ 高级程序语言设计 面向对象的程序设计 面向对象编程 继承 共49页.ppt
05-28
C++ 高级程序语言设计 面向对象的程序设计 面向对象编程 继承
C++-面向对象编程-000-面向对象
01-06
C+±面向对象编程-000-面向对象-2020-3-16 目录一、面向对象概述(1)封装(2)继承(3)多态二、面向对象与面向过程编程1.面向过程编程(1)软件重用性差(2)软件可维护性差(3)开发出的软件不能满足用户需要2.面向对象编程3.面向对象的特点(1)代码容易修改(2)代码复用性高(3)满足用户需求 一、面向对象概述 面向对象(Object Oriented ,OO)它是一种设计思想，现在这种思想已经不单应用在软件设计上，数据库设计、计算机辅助设计(CAD)、网络结构设计、人工智能算法设计等领域都开始应用这种思想。 针对面向对象思想应用的不同领域，面向对象又可以分为面向对象分析(O
C++面向对象程序设计习题继承与派生.pdf
09-30
C++面向对象程序设计习题继承与派生.pdf
C++ Void 指针 教程
neweastsun的专栏
03-28 4812
本文我们一起看看Void指针，了解它的用法及优缺点。 Void 指针 Void 指针也称为通用指针，可以指向任何类型对象的特殊类型指针。Void 指针声明与正常指针一样，使用void关键字： void* ptr; // ptr 是Void 指针 void指针可以指向任何类型对象，请看示例： int nValue; float fValue; struct Something { int n; float f; }; Something sValue; void* ptr; pt.
C++基础（五）--void关键字
热门推荐
weixin_43443648的博客
08-12 1万+
void关键字 C++指针
C++ 类和对象学习 —— 继承
xUeeeto_的博客
08-12 175
1.6 继承 利用继承技术，可以减少重复代码 1.6.1 继承的基本语法 普通实现 #include <iostream> #include <string> using namespace std; //普通实现页面 // Java 页面 class Java { public: void header() { cout << "首页、公开课、登陆、注册……（公共头部）" << endl; } void footer() { cout &l
面向对象程序设计C++实验大纲
10-15
* 面向对象程序设计：C++支持面向对象程序设计，允许用户定义类和对象，并使用继承、多态性和封装等机制实现面向对象程序设计。 * 泛型编程：C++支持泛型编程，允许用户定义模板函数和模板类，以便于编写通用的代码...
c++面向对象程序设计(与“对象”有关文档共416张).pptx
11-14
面向对象程序设计是一种基于对象和类的编程范式，它起源于Simula 67语言，并在Smalltalk等语言中得到进一步发展。这种编程方法不仅仅局限于程序设计和软件开发，而是广泛应用于数据库系统、人机交互界面、分布式系统...
面向对象的程序设计-个人复习笔记
10-26
以下是一些关于C++面向对象编程的重要知识点： 1. **类与对象**：类是数据结构和操作这些数据的方法的集合，而对象是类的实例。在C++中，我们使用`class`关键字来定义类，类可以包含数据成员（变量）和成员函数...
2023年C++面向对象程序设计模拟试题四.doc
11-05
2023年C++面向对象程序设计模拟试题四 本文将对 2023 年 C++ 面向对象程序设计模拟试题四进行详细的知识点解析。 一、单项选择题 1. 关于 C++ 函数的说明中，对的的是（ ）。 答案：C）调用一个函数之前，假如还...
面向对象——继承（c++）
weixin_48560325的博客
07-26 2265
继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础，上进行扩展，增加功能。这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构。体现了由简单到复杂的认识过程。百度百科（继承）通过继承(inheritance)的机制可对类(class)分层，提供类型/子类型的关系。C++通过类派生(classderivation)的机制来支持继承。被继承的类称为基类(baseclass)或超类(superclass)，新产生的类为。......
设计模式使用c++实现
qqwangfan的专栏
12-21 257
学习《大话设计模式》，按照自己的体会写的c++代码，仅用于记录，有问题欢迎指出。 //FotoryMode.h #pragma once #include <string> template<class T> class Operation { public: Operation(T numA,T numB):m_numA(numA),m_numB(numB) { } Operation() = default; virtual ~Operation() = de
面向对象程序设计C++——日期时间类编程（继承）
ChristensonLee的博客
05-08 3888
【问题描述】 编程定义日期类Date和时间类Time，Date类的数据成员为年、月、日，Time类则为时、分、秒。Date和Time类共同派生出日期时间类DateTime类。部分代码见代码区。请分析代码功能、设计各类并完善程序，使给出的程序代码正确执行。 Date类中数据输出格式：cout << year << "/" << month << "/" << day << endl; Time类中数据输出格式：cout <<
面向对象程序（C++）设计基础
铁路十六宿舍的博客
02-12 1660
本文由浅入深的对面向对象语言涉及的概念进行了详解，以C++给读者针对重要的概念举例，帮助读者能够快速实现从过程语言（c）到面向对象语言的编程思路转换。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] 停车场车位统计(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-15 89
K小姐经营着一个特定大小的停车场，停车场可以看成一个数组 $cars[]$，其中 $1$ 表示有车，$0$ 表示没车。现在停车场内停放着大小不一的车辆，其中小车占一个车位(长度 $1$)，货车占两个车位(长度 $2$)，卡车占三个车位(长度 $3$)。 K小姐想知道，按照当前停车场的停放情况，最少有多少辆车停在停车场内。你能帮帮她吗？ ### 输入描述 输入一个由 $0$ 和 $1$ 组成的字符串，以逗号分隔，表示停车场的车位情况。其中 $1$ 表示有车，$0$ 表示没车，字符串长度不超过 $1000
C++ 72 之 友元和类模版
最新发布
LSG_Down的博客
06-18 243
【代码】C++ 72 之 友元和类模版。
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 1170
Deque（双端队列）是C++ STL中的一种序列容器
C的I/O操作
weidl001的博客
06-17 719
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
C++ shared_ptr
qq_40135848的博客
06-15 1527
C++ shared_ptr
C++ 面向对象 - 类的继承与派生
07-29
C++中的类继承和派生是面向对象编程中的重要概念。在C++中，可以使用公有继承、保护继承和私有继承来实现类的继承和派生。 公有继承是最常见的一种继承方式，它可以使得基类的公有成员在派生类中仍然是公有的，保护...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大嘤三喵军团

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值