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

最新推荐文章于 2024-11-08 23:39:16 发布
最新推荐文章于 2024-11-08 23:39:16 发布
阅读量774 收藏
点赞数
分类专栏： 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;
}

 

C++ STL学习与面向对象编程实践
09-14
内容概要：本文为《C++ 入门与 STL 学习》的系列笔记汇编，包含了 C++ 基础、STL（Standard Template Library）的各种容器与算法的学习，及类的设计、继承、多态等面向对象特性的讲解与应用。重点涵盖了 C++ 中容器...
C++ 类和对象学习 —— 继承
xUeeeto_的博客
08-12 225
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++面向对象程序设计课程大作业-通讯录管理系统
05-21
本项目是学习C++面向对象编程的实战案例，通过设计和实现通讯录管理系统，学生可以深入理解面向对象编程的概念和技巧，并提升解决问题的能力。同时，项目的完整流程，包括需求分析、设计、编码、测试，也能帮助学生...
面向对象程序设计(C++)实验报告.doc
06-14
通过这个实验，学习者可以深入理解面向对象编程的关键概念，包括类的设计、继承关系的建立、构造和析构函数的使用，以及如何通过主函数进行实际操作。这为后续更复杂的应用和系统设计打下了坚实的基础。
C++面向对象程序设计习题继承与派生.pdf
09-30
"C++面向对象程序设计习题继承与派生.pdf" 继承是面向对象程序设计中的一种重要机制，它允许一个类继承另一个类的属性和行为特征。通过继承，新类可以从现有类中获得特征，从而达到代码复用的目的。在C++中，继承...
C++面向对象程序设计-学生管理系统
03-11
《C++面向对象程序设计-学生管理系统》 在IT领域，C++是一种强大的编程语言，以其面向对象的特性被广泛应用于系统开发，特别是在构建复杂的、性能要求高的应用中。本项目“学生管理系统”就是利用C++的面向对象编程...
编译器、IDE对C/C++新标准的支持
编程语言技巧经验分享
11-08 659
很遗憾的是，微软VC++对C99的支持直到VS2015才基本完全支持，在VS2012之前，仅仅支持C89. 也正是2015年之前，这么多人骂微软并纷纷转移到其它C语言编译器的原因。VS2019开始才正式宣布支持C11/C17.对于C++标准，VS2013开始支持C++11，VS2017支持C++17, VS2019支持C++20, 显然，微软更偏爱C++.
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 77
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
C++builder中的人工智能（15）：C++高斯误差线性单元（GELU）
最新发布
caridle的专栏
11-08 365
激活函数（phi()），也称为转移函数或阈值函数，它根据净输入函数的给定值（sum）确定激活值（a = phi(sum)）。在这里，sum是它们权重中的信号之和，激活函数是这个和的新值，具有给定的函数或条件。换句话说，激活函数是将所有加权信号的和转换为该信号的新激活值的方法。有不同类型的激活函数，通常使用的是线性（恒等）、双极性和逻辑（sigmoid）函数。在C++（以及大多数编程语言）中，你可以创建自己的激活函数。注意，sum是净输入函数的结果，它计算所有加权信号的和。我们将使用这些作为输入函数的结果。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 20
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 402
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
算法|牛客网华为机试31-40C++
奇树谦的博客
11-04 724
计算第5次落地后球经过的距离，除了第一次只经过一次，所以距离最后在减去初始长度，高度每次减去一半。for循环遍历一次，从后往前，如果是字符组成单词等遇到空格或者非字母输出。直接用sort函数就是按着ASCII码从小到大排序的。找每行每列的相加差1的数学规律，再每行输出。
C++ 编程基础（4）函数 | 4.1、函数概述
个人技术博客
11-04 228
在C++中，函数通过函数定义来创建，其语法包括返回类型、函数名、参数列表（可选）和函数体。函数指针是指向函数的指针变量。因此函数指针本质上是一个指针变量，只不过该指针变量指向函数。C/C++中，每一个函数都有一个入口地址，函数指针就指向函数的入口地址，可以通过函数指针来调用函数。return 0;// pfnFunc保存的就是func函数地址，pfnFunc与func值是一样的return 0;输出结果0040135000401350。
c++ 分治算法
www_dong的博客
11-08 655
分治算法是一种重要的算法设计范式，其核心思想是将一个复杂的问题分解为多个规模较小的相同问题，逐步解决这些较小的问题，最后将这些问题的解合并成原问题的解。
C语言 流程控制语句
2201_75297369的博客
11-05 484
时间：2024.11.5。
C++面向对象高级开发（C++2.0）
Oafz的博客
11-06 497
autoLambdasUnordered容器arraytupleRegEx。
STL：标准模板库
qincjun的博客
11-04 335
2.2 C++中也是存在基础类型和自定义类型（类），但是C++在自定义类型中做了扩展，不仅存放了基础类型，也可以在类中使用函数——你们可以看一下我写的这篇文章《struct和C++的类》，虽然技术含量不高，但是可以推演祖师爷创建C++的一些思想；
C++中的重载：详细介绍与实现方法
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
11-08 16
重载是C++编程中的一项重要特性，它允许我们在同一个作用域内定义多个具有相同名称但参数列表不同的函数或运算符。通过重载，我们可以实现更灵活和高效的代码设计，提高代码的可读性和易用性。在本文中，我们详细介绍了C++中的函数重载和运算符重载，并通过具体示例展示了如何实现它们。希望这些内容能够帮助读者更好地理解和应用重载这一特性。
c++中final修饰的使用
hxj_686的博客
11-05 108
final可以用来修饰类和修饰类的虚函数。
C++面向对象程序设计：类、对象与继承总结
"C++面向对象程序设计复习资料" 在C++中，面向对象程序设计（Object-Oriented Programming，OOP）是一种强大的编程范式，它基于“对象”的概念。对象是C++的核心，OOP之父Alan Kay认为对象具备以下几个关键特性： ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大嘤三喵军团

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

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

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

打赏作者

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

抵扣说明：

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

余额充值