C++核心编程篇

yangyang_z

已于 2022-03-23 18:00:33 修改

阅读量822

点赞数 1

分类专栏： C++ 文章标签： c++ 多态

于 2021-02-06 17:30:05 首次发布

C++ 专栏收录该内容

24 篇文章 2 订阅

订阅专栏

C++核心编程

084_01程序的内存模型-内存四区-代码区

内存分区模型
C++程序在执行时，将内存大方向划分为4给区域

代码区：存放函数体的二进制代码，由操作系统进行管理的
全局区：存放全局变量和静态变量以及常量
栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
内存四区意义：
不同的区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程
程序运行前
在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域
代码区：
存放CPU执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外的修改了它的指令

085_02程序的内存模型-内存四区-全局区

全局区：
全局变量和静态变量存放在此。
全局区还包含常量区，字符串常量和其他常量也存放在此。
该区域的数据在程序结束后由操作系统释放。

#include<iostream>
#include<string>
using namespace std;
//全局变量
int g_a = 10, g_b = 20;
const int c_g_a = 30;
int main()
{
	//全局区
	//全局变量、静态变量、常量
	//创建普通局部变量
	int a = 10, b = 20;
	cout << "局部变量a的地址为：" << (int)&a << endl;
	cout << "局部变量b的地址为：" << (int)&b << endl;
	cout << "全局变量g_a的地址为：" << (int)&g_a << endl;
	cout << "全局变量g_b的地址为：" << (int)&g_b << endl;
	//静态变量
	static int s_a = 10, s_b = 20;
	cout << "静态变量s_a的地址为：" << (int)&s_a << endl;
	cout << "静态变量s_b的地址为：" << (int)&s_b << endl;
	//常量
	//字符串常量
	cout << "字符串常量的地址为： " << (int)&"hello world" << endl;
	//const修饰的变量
	//const 修饰的全局变量，const修饰的局部变量
	cout << "const 修饰的全局变量c_g_a的地址为：" << (int)&c_g_a << endl;
	const int c_a = 30;
	cout << "const 修饰的局部变量c_a的地址为：" << (int)&c_a << endl;
	system("pause");
	return 0;
}

在这里插入图片描述

总结：

C++中在程序运行前分为全局区和代码区
代码区特点是共享和只读
全局区中存放
常量区存放const修饰的全局变量和字符串变量

086_03程序的模型-内存四区-栈区

程序运行后
栈区：
由编译器自动分配释放，存放函数的参数值，局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

#include<iostream>
#include<string>
using namespace std;
//栈区数据注意事项 --不要返回局部变量的地址
//栈区的数据由编译器管理开辟和释放

int* func(int b){     //形参数据也会放在栈区
	int a = 10;  //局部变量，存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;   //返回局部变量的地址
}
int main()
{
	//接受func函数的返回值
	int *p = func(10);
	cout << *p << endl;   //第一次可以打印正确的数字，是因为编译器做了保留
	cout << *p << endl;   //第二次这个数据就不再保留了
	system("pause");
	return 0;
}

在这里插入图片描述

087_04程序的内存模型-内存四区-堆区

堆区：
由程序员分配释放，若程序员不释放，程序结束时由操作系统回收
在C++中主要利用new在堆区开辟内存

#include<iostream>
#include<string>
using namespace std;

int *func(){
	//利用new关键字 可以将数据开辟到堆区
	//指针  本质上也是局部变量，放在了栈上，指针保存的数据是放在堆区
	int *p = new int(10);
	return p;
}
int main()
{
	//在堆区开辟数据
	int *p = func();
	cout << *p << endl;
	system("pause");
	return 0;
}

在这里插入图片描述

088_05程序的内存模型-new运算符

C++中利用new操作符在堆区开辟数据
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
语法：new 数据类型
利用new创建数据，会返回该数据对应的类型的指针

#include<iostream>
#include<string>
using namespace std;

//1、new的基本语法
int *func(){
	//在堆区创建整型数据
	//new返回的是该数据类型的指针
	int *p =new int(10);
	return p;
}
static void test01(){
	int *p = func();
	cout << *p << endl;
	cout << *p << endl;
	//堆区的数据由程序员管理开辟，程序员管理释放
	//如果想要释放堆区的数据，利用关键字delete
	delete p;
	//cout << *p << endl;//内存已经被释放，再次访问就是非法操作，会报错
}
//2、在堆区利用new开辟数组
static void test02(){
	//创建10个整型数据的数组，在堆区
	int *arr = new int[10];   //10代表数组中有10个元素
	for (int i = 0; i < 10; i++){
		arr[i] = i + 100;     //给10个元素赋值 100 ~ 109
	}
	for (int i = 0; i < 10; i++){
		cout << *arr << "  ";
		arr++;
	}
	cout << endl;
	//释放堆数组
	//释放数组的时候要加[]才可以
	delete[] arr;
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

089_06C++中引用的基本语法

引用的基本使用
作用：给变量起别名
语法：数据类型 &别名 = 原名

#include<iostream>
#include<string>
using namespace std;
int main()
{
	//引用的基本语法
	//数据类型  &别名 = 原名
	int a = 10;
	//创建引用
	int &b = a;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	b = 100;
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	system("pause");
	return 0;
}

在这里插入图片描述

090_07C++中的引用-引用的注意事项

引用注意事项

引用必须初始化
引用在初始化后，不可以改变

#include<iostream>
#include<string>
using namespace std;
int main()
{
	//引用的注意事项
	//引用必须要初始化
	int a = 10;
	//int &b;
	int &b = a;
	//引用一旦初始化后就不可以更改
	int c = 20;
	 b = c; //赋值操作，而不是更改引用
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
	system("pause");
	return 0;
}

091_08C++中的引用-引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参

#include<iostream>
#include<string>
using namespace std;
//值传递
static void mySwap01(int a, int b){
	int temp = a;
	a = b;
	b = temp;
}
//指针传递
static void mySwap02(int *a, int *b){
	int temp = *a;
	*a = *b;
	*b = temp;
}
//引用传递
static void mySwap(int &a, int &b){
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 10, b = 20;
	mySwap(a, b);
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	system("pause");
	return 0;
}

总结：通过引用参数产生的效果同按地址传递是一样的，引用的语法更简单。

093_10C++中的引用-引用做函数返回值

作用：引用是可以作为函数的返回值存在的
注意：不要返回局部变量的引用
用法：函数调用作为左值
在这里插入图片描述

#include<iostream>
#include<string>
using namespace std;
//引用做函数的返回值
//1、不要返回局部变量的引用
static int& test01(){
	int a = 10;   //局部变量存放在四区中的  栈区
	return a;
}
//2、函数的调用可以作为左值
static int& test02(){
	//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
	static int a = 10;
	return a;
}
int main()
{
	int &ref = test01();
	cout << " ref = " << ref << endl;    //第一次结果正确，是因为编译器做了保留
	cout << " ref = " << ref << endl;    //第二次结果错误，是因为a的内存已经被释放了
	int &ref2 = test02();
	test02() = 1000;
	cout << " ref2 = " << ref2 << endl;
	cout << " ref2 = " << ref2 << endl;
	system("pause");
	return 0;
}

093_10C++中的引用-引用的本质

本质：引用的本质在C++内部实现就是一个指针常量
在这里插入图片描述

094_11C++中的引用-常量引用

作用：常量引用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参改变实参

#include<iostream>
#include<string>
using namespace std;
static void showValue(const int &val){
	//val = 1000;
	cout << "val = " << val << endl;
}
int main()
{
	//常量引用
	//使用场景，用来修饰形参，防止误操作
	int a = 10;
	//加上const之后 编译器将代码修改为 int temp = 10; const int &ref = temp;
	const int &ref = 10;  //引用必须引一块合法的内存空间
	//ref = 30;    //加入const之后变为只读，不可修改
	int b = 100;
	showValue(b);
	system("pause");
	return 0;
}

095_12函数高级-函数的默认参数

在C++中，函数的形参列表中的形参是可以有默认值的
语法：返回值类型函数名（参数 = 默认值）{}

#include<iostream>
#include<string>
using namespace std;
//函数的默认参数 
//如果我们自己传入数据，就用自己的数据，如果没有，那么就用默认值
//语法：返回值类型  函数名(形参 = 默认值){}
static  int func(int a, int b =20 , int c = 30){
	return a + b + c;
}
//注意事项
//1、如果某个位置已经有了默认参数，
//那么从这个位置往后，从左到右都必须右默认参数
//2、如果函数的申明有了默认参数，函数实现就不能有默认参数
int main()
{
	cout << func(10,30) << endl;
	system("pause");
	return 0;
}

096_13函数高级-函数的占位参数

C++中函数的形参列表里可以有占位参数，用来占位，调用函数的时候必须填补该位置
语法：返回值类型函数名(数据类型){}

#include<iostream>
#include<string>
using namespace std;
//占位参数
//占位参数还可以有默认参数
static void func(int a, int =20){
	cout << "This is func" << endl;
}
int main()
{
	func(10, 2);
	system("pause");
	return 0;
}

097_14函数高级-函数重载-基本语法

作用：函数名可以相同，提高复用性
函数重载满足条件：

同一个作用域下
函数名称相同
函数参数类型不同，或者个数不同或者顺序不同
注意：函数的返回值不可以作为函数重载的条件

#include<iostream>
#include<string>
using namespace std;
//函数重载满足的条件
//1、同一个作用域下
//2、函数名称相同
//3、函数参数类型不同，或者个数不同，或者顺序不同
static void func(){
	cout << "This is func" << endl;
}
static void func(int a){
	cout << "This is funcfunc(int a)" << endl;
}
static void func(double a){
	cout << "This is func(double a)" << endl;
}
static void func(double a,int b){
	cout << "This is func(double a,int b)" << endl;
}
static void func(int a, double b){
	cout << "This is func(int a, double b)" << endl;
}
int main()
{
	func();
	func(2);
	func(2.1);
	func(2.1, 2);
	func(2, 2.1);
	system("pause");
	return 0;
}

098_15函数高级-函数重载-注意事项

引用作为重载的条件
函数重载碰到函数默认参数
//当函数重载碰到了默认参数，出现二义性，报错，尽量避免

#include<iostream>
#include<string>
using namespace std;
//函数重载的注意事项
//1、引用作为重载的条件
static void func(int &a){      //int &a = 10;  不合法
	cout << "func(int &a)调用" << endl;
}
static void func(const int &a){
	cout << "func(const int &a)调用" << endl;
}
//2、函数重载碰到了默认参数
static void func2(int a, int b = 10){
	cout << "func2(int a, int b = 10)的调用" << endl;
}
static void func2(int a){
	cout << "func2(int a)的调用" << endl;
}

int main()
{
	const int a = 10;
	func(a);
	int b = 10;
	func(b);
	func(10);
	//func2(10); //当函数重载碰到了默认参数，出现二义性，报错，尽量避免
	system("pause");
	return 0;
}

099_16类和对象-封装-属性和行为作为整体

C++面向对象的三大特性为:封装、继承、多态
面向对象程序设计的核心思想是数据抽象、继承和动态绑定。通过使用数据抽象，我们可以将类的接口与实现分离，使用继承可以定义相似的类型并对其相似关系建模使用动态绑定，可以在一定程度上忽略相似类型的区别而以统一的方式使用它们的对象。
封装的意义

将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制

#include<iostream>
#include<string>
using namespace std;
//设计一个圆类，求圆的周长
//圆求周长的公式 2*PI*r
//class代表设计一个类，类后面紧跟着就是类名称
const double PI = 3.14;
class Circle{
public:
	double m_r;
	double calculateZC(){
		return 2 * PI*m_r;
	}
};
int main()
{
	Circle cl;
	cl.m_r = 10;
	double zc = cl.calculateZC();
	cout << "圆的周长为：" << zc << endl;
	system("pause");
	return 0;
}

100_17类和对象-封装-案例-设计学生类

设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号

#include<iostream>
#include<string>
using namespace std;
//设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
class Student{
public:
	void setName(const string &name){
		m_name = name;
	}
	string showName(){
		return m_name;
	}
	void setNum(const int &num){
		m_num = num;
	}
	int showNum(){
		return m_num;
	}
private:
	string m_name;
	int m_num;
};
int main()
{
	Student st;
	st.setName("张三");
	st.setNum(1209);
	cout << "姓名:" << st.showName() << "\t学号：" << st.showNum() << endl;
	system("pause");
	return 0;
}

101_18类和对象-封装-访问权限

封装的意义二：
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：

public 公共权限
protected 保护权限
private 私有权限

#include<iostream>
#include<string>
using namespace std;
//访问权限
//1、公共权限   public    成员类内可以访问，类外可以访问
//2、保护权限   protected 成员类内可以访问，类外不可以访问，儿子不可以访问父亲中的保护内容
//3、私有权限   private   成员类内可以访问，类外不可以访问，儿子不可以访问父亲的私有内容
class Person{
public:
	string m_Name;
	void func(){
		m_Name = "张三";
		m_Car = "奥迪";
		m_Password = 12345;
	}
protected:
	string m_Car;
private:
	int m_Password;
};
int main()
{
	Person p1;
	p1.m_Name = "李四";
	//p1.m_Car = "拖拉机";
	//p1.m_Password = 1230;
	system("pause");
	return 0;
}

102_19类和对象-封装-C++中class和struct的区别

在C++中struct和class唯一的区别就在于默认的访问权限不同
区别：

struct默认权限为公共
class 默认权限为私有

#include<iostream>
#include<string>
using namespace std;
//struct 和 class区别
//sturct 默认权限是公共public
//class  默认权限是私有private
class C{
	int m_A;
};
struct B{
	int m_B;
};
int main()
{
	B b;
	b.m_B = 10;
	C c;
	//c.m_A;
	system("pause");
	return 0;
}

103_20类和对象-封装-成员属性私有化

成员属性设置为私有
优点1：将所有成员属性设置为私有，可以自己控制读写权限
优点2：对于写权限，我们可以检测数据的有效性

#include<iostream>
#include<string>
using namespace std;
//成员属性设置为私有
//1、可以自己控制读写权限
//2、对于写可以检测数据的有效性
//设计人类
class Person{
public:
	void setName(const string &name){
		m_Name = name;
	}
	string getName(){
		return m_Name;
	}
	//获取年龄 可读可写，如果想修改（0-150）
	int getAge(){ 
		m_Age = 10;
		return m_Age;
	}
	void setAge(const int age){
		if (age <0 || age >150){
			cout << "你这个老妖精！！！" << endl;
		}
		m_Age = age;
	}
	void setLoverName(const string &name){
		m_Lover = name;
	}
private:
	string m_Name;  //姓名  可读可写
	int m_Age;      //年龄  只读
	string m_Lover; //情人  只写
};
int main()
{
	Person p;
	p.setName("张三");
	//设置情人为苍井
	p.setLoverName("苍井");
	p.setAge(1000);
	cout << "姓名： " << p.getName() << "\t年龄：" << p.getAge() <<  endl;
	system("pause");
	return 0;
}

104_21类和对象-封装-设计案例1-立方体类

设计立方体Cube
求出立方体的面积和体积
分别用全局函数和成员函数判断两个立方体是否相等。
在这里插入图片描述

#include<iostream>
#include<string>
using namespace std;
class Cube{
public:
	void setL(int l){
		m_L = l;
	}
	int getL(){
		return m_L;
	}
	void setH(int h){
		m_H = h;
	}
	int getH(){
		return m_H;
	}
	void setW(int w){
		m_W = w;
	}
	int getW(){
		return m_W;
	}
	//获取立方体面积
	int calculateS(){
		return 2 * (m_L*m_H + m_L*m_W + m_H*m_W);
	}
	//获取立方体体积
	int claculateV(){
		return m_L*m_H*m_W;
	}
	//利用成员函数判断两个立方体是否相等
	bool compareSameByClass(Cube &c){
		if (m_L == c.getL() && m_H == c.getH() && m_W == c.getW()){
			return true;
		}
		return false;
	}
private:
	int m_L;
	int m_H;
	int m_W;
};

//利用全局函数判断两个立方体是否相等
bool compareSame( Cube &c1, Cube &c2){
	if (c1.getL() == c2.getL() && c1.getH() == c2.getH() && c1.getW() == c2.getW()){
		return true;
	}
	return false;
}
int main()
{
	Cube c1;
	c1.setH(10), c1.setW(10), c1.setL(10);
	cout << "c1体积：" << c1.claculateV() << "\tc1面积：" << c1.calculateS() << endl;
	Cube c2;
	c2.setH(10), c2.setW(20), c2.setL(10);
	//利用全局函数判断
	bool ret = compareSame(c1, c2);
	if (ret){
		cout << "c1 和 c2是相等的" << endl;
	}
	else{
		cout << "c1和c2是不相等的" << endl;
	}
	//利用成员函数判断
	ret = c1.compareSameByClass(c2);
	if (ret){
		cout << "成员函数判断c1 和 c2是相等的" << endl;
	}
	else{
		cout << "成员函数判断c1和c2是不相等的" << endl;
	}
	system("pause");
	return 0;
}

105_22类和对象-对象特性-设计案例2-点和圆的关系

设计一个圆形类Circle，和一个点类Point，计算点和圆的关系
在这里插入图片描述

#include<iostream>
#include<string>
using namespace std;
//点和圆的关系
//圆类
class Point{
public:
	void setX(int x){
		m_X = x;
	}
	int getX(){
		return m_X;
	}
	void setY(int y){
		m_Y = y;
	}
	int getY(){
		return m_Y;
	}
private:
	int m_X;
	int m_Y;
};
class Circle{
public:
	void setR(int r){
		m_R = r;
	}
	int getR(){
		return m_R;
	}
	void setCenter(Point center){
		m_Center = center;
	}
	Point getCenter(){
		return m_Center;
	}
private:
	int m_R; //半径
	Point m_Center;
};
//判断点和圆的关系
static void isInCircle(Circle&c, Point &p){
	//计算两点之间的距离平方
	int distance =
	(c.getCenter().getX() - p.getX())*(c.getCenter().getX() - p.getX()) +
	(c.getCenter().getY() - p.getY())*(c.getCenter().getY() - p.getY());
	//计算半径的平方
	int rDistance = c.getR()*c.getR();
	//判断关系
	if (distance == rDistance){
		cout << "点在圆上 " << endl;
	}
	else if (distance > rDistance){
		cout << "点在圆外" << endl;
	}
	else {
		cout << "点在圆内" << endl;
	}
}
int main()
{
	Circle c;
	c.setR(10);

	Point center;
	center.setX(10);
	center.setY(0);
	c.setCenter(center);
	
	Point p;
	p.setX(10);
	p.setY(10);
	isInCircle(c, p);
	system("pause");
	return 0;
}

106_23类和对象-对象特性-构造函数

构造函数和析构函数
对象的初始化和清理也是两个非常重要的安全问题

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作

构造函数语法：类名(){}

构造函数，没有返回值也不写void
函数名称与类名相同
构造函数可以有参数，因此可以发生重载
程序在调用对象时候会自动调用构造，无须手动调用，而且只会调用一次
析构函数语法：~类名(){}
析构函数，没有返回值也不写void
函数名称和类名相同，在名称前加上符号~
析构函数不可以有参数，因此不可以发生重载
程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

#include<iostream>
#include<string>
using namespace std;

class Person{
public:
	//1构造函数
	Person(){
		cout << "Person 构造函数的调用" << endl;
	}

	~Person(){
		cout << "Person 析构函数调用 " << endl;
	}
};
static void test01(){
	Person p;    //在栈上的数据，执行完毕，释放这个对象
}
int main()
{
	test01();
	system("pause");
	return 0;
}

107_24类和对象-对象特性-函数的分类以及调用

两种分类方式：

按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造
三种调用方式：
括号法
显示法
隐式转换法

#include<iostream>
#include<string>
using namespace std;
//构造函数的分类及调用
//按照参数分类  无参构造(默认构造)和有参构造
//按照类型分类  普通构造  拷贝构造
class Person{
public:
	Person(){
		cout << "Person 的默认构造函数调用" << endl;
	}
	 Person(int a){
		m_age = a;
		cout << "Person 的有参构造函数调用" << endl;
	}
	//拷贝构造函数
	Person(const Person &p){
		m_age = p.m_age;
		cout << "Person 的拷贝构造函数调用" << endl;
	}
	~Person(){
		cout << "Person 的析构造函数调用" << endl;
	}
	int m_age;
};
//调用
static void test01(){
	//括号法
	Person p;
	Person p2(10);
	Person p3(p2);
	//注意事项：
	//调用默认构造函数的时候不要加();
	//因为下面这行代码，编译器会认为是一个函数声明,不会认为是在创建对象
	//Person p1();

	//显示法
	Person p11;
	Person p22 = Person(10);
	Person p33 = Person(p22);
	Person(10);  //匿名对象，特点：当前行执行结束后，系统会立即回收匿名对象
	cout << "aaaa" << endl;
	//注意事项2 
	//不要利用拷贝构造函数，初始化匿名对象,编译器会认为Person(p3) = Person p3;  对象的声明
	//Person(p3);
	//隐士转换法
	Person p4 = 10;    //相当于 Person p4 = Person(10);  //有参构造
	Person p5 = p4;
	//explicit 可以阻止隐式转换
}
int main()
{
	test01();
	system("pause");
	return 0;
}

108_25类和对象-对象特性-拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况

使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值
以值方式返回局部对象

#include<iostream>
#include<string>
using namespace std;

//拷贝构造函数的调用时机
class Person{
public:
	Person(){
		cout << "Person 默认构造函数调用 " << endl;
	}
	Person(int age){
		m_Age = age;
		cout << "Person 有参构造函数调用 " << endl;
	}
	Person(const Person&p){
		m_Age = p.m_Age;
		cout << "Person 拷贝构造函数调用 " << endl;
	}

	~Person(){
		cout << "Person 默认析构函数调用 " << endl;
	}
	int m_Age;
};
//1、使用一个已经创建完毕的对象来初始化一个新对象
static void test01(){
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << endl;
}
//2、值传递的方式给函数参数传值
static void doWork(Person p){

}
static void test02(){
	Person p;
	doWork(p);
}
//3、以值方式返回局部对象
Person doWork2(){
	Person p1;
	cout << (int*)&p1 << endl;
	return p1;
}
static void test03(){
	Person p = doWork2();
	cout << (int *)&p << endl;
}
int main()
{
	test03();
	system("pause");
	return 0;
}

109_26类和对象-对象特性-构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

默认构造函数(无参，函数体为空)
默认析构函数(无参，函数体为空)
默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

如果用户定义有参构造，C++不在提供默认无参构造，但是会提供默认拷贝构造
如果用户定义拷贝构造函数，C++不会提供其他构造函数

#include<iostream>
#include<string>
using namespace std;
//构造函数调用规则如下：

//默认情况下，C++编译器至少给一个类添加3个函数
//1. 默认构造函数(无参，函数体为空)
//2. 默认析构函数(无参，函数体为空)
//3. 默认拷贝构造函数，对属性进行值拷贝
// 如果用户定义有参构造，C++不在提供默认无参构造，但是会提供默认拷贝构造
// 如果用户定义拷贝构造函数，C++不会提供其他构造函数
class Person{
public:
	Person(){
		cout << "Person的默认构造函数调用" << endl;
	}
	Person(int age){
		m_Age = age;
	}
	Person(const Person &p){
		m_Age = p.m_Age;
		cout << "Person的拷贝构造函数调用" << endl;
	}
	~Person(){
		cout << "Person的析构函数调用 " << endl;
	}
	int m_Age;
};
static void test01(){
	Person p;
	p.m_Age = 18;
	Person p2(p);
	cout << "p2的年龄为： " << p2.m_Age << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

110_27类和对象-对象特性-深浅拷贝

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作
浅拷贝带来的问题是堆区的内存重复释放
在这里插入图片描述
解决办法：利用深拷贝解决浅拷贝问题

#include<iostream>
#include<string>
using namespace std;
//深拷贝与浅拷贝
class Person{
public:
	Person(){
		cout << "Person的默认构造函数调用" << endl;
	}
	Person(int age,int height){
		m_Age = age;
		m_Height = new int(height);
	}
	//自己实现拷贝构造函数  解决浅拷贝带来的问题
	Person(const Person &p){
		m_Age = p.m_Age;
		//m_Height = p.m_Height;  编译器默认实现的就是这行代码
		//深拷贝操作
		m_Height = new int(*p.m_Height);
		cout << "Person的拷贝构造函数调用" << endl;
	}
	~Person(){
		//析构代码，将堆区开辟的数据做释放
		if (m_Height != nullptr){
			delete m_Height;
			m_Height = nullptr;
		}
		cout << "Person的析构函数调用 " << endl;

	}
	int m_Age;
	int *m_Height;  //身高
};
static void test01(){
	Person p1(18,180);
	cout << "p1的年龄为：" << p1.m_Age <<"身高: " << *p1.m_Height << endl;
	Person p2(p1);
	cout << "p2的年龄为：" << p2.m_Age << "身高: " << *p2.m_Height << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。

111_28类和对象-对象特征-初始化列表

作用：
C++提供了初始化列表语法，用来初始化属性
语法：构造函数():属性1（值1）…{}

#include<iostream>
#include<string>
using namespace std;
class Person{
public:
	Person(int a,int b ,int c) :m_A(a), m_B(b), m_C(c){

	}
	int m_A, m_B, m_C;
};
int main()
{
	Person p(10,20,30);
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
	system("pause");
	return 0;
}

112_29类和对象-对象特性-类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称为该成员为对象成员

class A{};
class B{
	A a;
};

B类中有对象A作为成员，A为对象成员
那么当创建B对象时，A与B的构造和析构的顺序如何呢

#include<iostream>
#include<string>
using namespace std;
class Phone{
public:
	string m_pName;
	Phone(string pname) :m_pName(pname){
		cout << "Phone的构造函数调用" << endl;
	}
	~Phone(){
		cout << "Phone的析构函数调用" << endl;
	}
};
class Person{
public:
	Person(string name, string pname) :m_Name(name), m_Phone(pname){
		cout << "Person的构造函数调用" << endl;
	}
	~Person(){
		cout << "Person的析构函数调用" << endl;
	}
	string m_Name;
	Phone m_Phone;
};
//当其他类对象作为本类的成员，构造时候先构造对象，再构造自身，析构相反。
static void test(){
	Person p("张三","Apple Max12");
	cout << p.m_Name << "拿着：" << p.m_Phone.m_pName << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述

113_31类和对象-对象特性-静态成员-静态成员函数

静态成员就是在成员比变量和成员函数前加上关键字static,称为静态成员
静态成员分为：

静态成员变量
所有对象共享同一份数据
在编译阶段分配内存
类内声明，类外初始化
静态成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量

#include<iostream>
#include<string>
using namespace std;
/*
- 静态成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量
*/
class Person{
public:
	//静态成员函数
	static void func(){
		m_A = 100;    //静态的成员函数可以访问静态成员变量
		//m_B = 100;  //静态的成员函数不可以访问非静态的成员变量,无法区分到底是哪个对象的m_B
		cout << "static void func调用" << endl;
	}
	static int m_A;  //静态成员变量
	int m_B;         //非静态成员变量
	//静态成员函数是有访问权限的
};
int Person::m_A = 0; 
static void test(){
	//1、通过对象访问
	Person p1;
	p1.func();
	//2、通过类名访问
	Person::func();
}
int main()
{
	test();
	system("pause");
	return 0;
}

114_31 static关键字总结

作用：

修饰普通变量，修改变量的存储区域和生命周期，使变量存储在静态区，在 main 函数运行前就分配了空间，如果有初始值就用初始值初始化它，如果没有初始值系统用默认值初始化它。
修饰普通函数，表明函数的作用范围，仅在定义该函数的文件内才能使用。在多人开发项目时，为了防止与他人命令函数重名，可以将函数定位为 static。
修饰成员变量，修饰成员变量使所有的对象只保存一个该变量，而且不需要生成对象就可以访问该成员。
修饰成员函数，修饰成员函数使得不需要生成对象就可以访问该函数，但是在 static 函数内不能访问非静态成员。

114_32类和对象-对象特性-成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储
只有非静态成员变量才属于类的对象上

#include<iostream>
#include<string>
using namespace std;
//成员变量和成员函数是分开存储的
class Person{
public:
	int m_A;              //非静态成员变量，属于类的对象上
	static int  m_B;      //静态成员变量，不属于类对象上
	void func(){}         //非静态成员函数，不属于类的对象
	static void func2(){} //静态成员函数，不属于类的对象上
};
static void test(){
	Person p;
	//C++编译器会给每个空对象也分配一个字节空间，是为了区分空对象占内存的位置
	//每个空对象也应该有一个独一无的内存地址
	cout << "size of p = " << sizeof(p) << endl;
}

static void test02(){
	Person p;
	cout << "size of p = " << sizeof(p) << endl;
}

int main()
{
	test02();
	system("pause");
	return 0;
}

115_33类和对象-对象特性-this指针的用途

C++中成员变量和成员函数是分开存储的，每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象共用一块代码
那么问题是：这一块代码是如何区分那个对象调用自己的呢？
C++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象
this指针的用途：

当形参和成员变量同名时，可用this指针区分
在类的非静态成员函数中返回对象本身，可是使用return *this

#include<iostream>
#include<string>
using namespace std;
class Person{
public:
	Person(int age){
		//this指针指向 被调用的成员函数 所属的对象 
		this->age = age;
	}
	Person& PersonAddAge(Person &p){
		this->age += p.age;
		return *this;
	}
	int age;
};
//解决名称冲突
static void test(){
	Person p1(18);
	cout << "p1的年龄为：" << p1.age << endl;
}
//返回对象本身用 *this
static void test02(){
	Person p1(10);
	Person p2(20);
	//链式编程思想
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2的年龄为：" << p2.age << endl;
}
int main()
{
	test02();
	system("pause");
	return 0;
}

116_33 this指针总结

this指针

this指针是一个隐含于每一个非静态成员中的特殊指针。它指向正在被该成员函数操作的那个对象。
当对一个对象调用成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数，每次成员函数存取数据成员时，由隐含使用this指针。
当一个成员函数被调用时，自动向它传递一个隐含的参数，该参数是一个指向这个成员函数所在的对象的指针。
this 指针被隐含地声明为: ClassName * const this，这意味着不能给 this 指针赋值；在 ClassName 类的 const 成员函数中，this 指针的类型为：const ClassName * const，这说明不能对 this 指针所指向的这种对象是不可修改的（即不能对这种对象的数据成员进行赋值操作）；
this 并不是一个常规变量，而是个右值，所以不能取得 this 的地址（不能 &this）。
在以下场景中，经常需要显式引用 this 指针：
i.为实现对象的链式引用
ii.为避免对同一对象进行赋值操作；
iii.在实现一些数据结构时，如list。

116_34类和对象-对象特性-空指针访问成员函数

C++中空指针也可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性
if (this == nullptr){
return;
}

#include<iostream>
#include<string>
using namespace std;
class Person{
public:
	void showClassName(){
		cout << "this is Person class" << endl;
	}
	void showPersonAge(){
		//报错的原因是因为传入的指针是nullptr
		if (this == nullptr){
			return;
		}
		cout << "age = " << this->m_Age << endl;
	}
	int m_Age;
};
static void test(){
	Person *p = nullptr;
	p->showClassName();
	p->showPersonAge();
}

int main()
{
	test();
	system("pause");
	return 0;
}

117_35类和对象-对象特性-const修饰成员函数

常函数：

成员函数后加const后我们称这个函数为常函数
常函数内不可以修改成员属性
成员属性声明时加关键字mutable后，在常函数中依然可以修改
常对象：
声明对象前加const称该对象为常对象
常对象只能调用常函数

#include<iostream>
#include<string>
using namespace std;
//常函数
class Person{
public:
	//this指针的本质  是指针常量，指针常量的本质是不可以修改的
	//const Person * const this;
	//在成员函数后面加const，修饰的是this指针，让指针指向的值也不可以修改
	void showPerson()const{
		this->m_B = 100;
		//m_A = 100;
		//this = nullptr;  //this指针是不可以修改指针的指向的

	}
	void func(){
		m_A = 100;
	}
	int m_A;
	mutable int m_B;    //特殊变量，即使在常函数中，也可以修改这个值,加关键字mutable
};
static void test01(){
	Person p;
	p.showPerson();
	
}
//常对象
static void test02(){
	const Person p;    //在对象前加const,变为常对象
	//p.m_A = 100;
	p.m_B = 200;       //m_B是特殊值，在常对象下也可以修改
	//常对象只能调用常函数
	p.showPerson();
	//p.func();    //常对象 不可以调用普通成员函数，因为普通成员函数可以修改属性
}
int main()
{
	test01();
	system("pause");
	return 0;
}

118_35 const关键字总结

const作用

修饰变量，说明该变量不可以被改变；
修饰指针，分为指向常量的指针和指针常量；
常量引用，经常用于形参类型，即避免了拷贝，又避免了函数对值的修改；
修饰成员函数，说明该成员函数内不能修改成员变量。

// 类
class A
{
private:
    const int a;                // 常对象成员，只能在初始化列表赋值
public:
    // 构造函数
    A():a(0) { };
    A(int x) : a(x) { };        // 初始化列表
    // const可用于对重载函数的区分
    int getValue();             // 普通成员函数
    int getValue() const;       // 常成员函数，不得修改类中的任何数据成员的值
};
void function()
{
    // 对象
    A b;                        // 普通对象，可以调用全部成员函数
    const A a;                  // 常对象，只能调用常成员函数、更新常成员变量
    const A *p = &a;            // 常指针
    const A &q = a;             // 常引用
    // 指针
    char greeting[] = "Hello";
    char* p1 = greeting;                // 指针变量，指向字符数组变量
    const char* p2 = greeting;          // 指针变量，指向字符数组常量
    char* const p3 = greeting;          // 常指针，指向字符数组变量
    const char* const p4 = greeting;    // 常指针，指向字符数组常量
}
// 函数
void function1(const int Var);           // 传递过来的参数在函数内不可变
void function2(const char* Var);         // 参数指针所指内容为常量
void function3(char* const Var);         // 参数指针为常指针
void function4(const int& Var);          // 引用参数在函数内为常量
// 函数返回值
const int function5();      // 返回一个常数
const int* function6();     // 返回一个指向常量的指针变量，使用：const int *p = function6();
int* const function7();     // 返回一个指向变量的常指针，使用：int* const p = function7();

118_36类和对象-友元-全局函数做友元

在程序中，有些私有属性，也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术。
友元的目的是让一个函数或者类访问另外一个类中私有成员
友元的关键字friend
友元的三种实现

全局函数做友元
类做友元
成员函数做友元

#include<iostream>
#include<string>
using namespace std;
class Building{
	//goodGay全局函数是Building好朋友，可以访问Building中私有成员
	friend void goodGay(Building *building);
public:
	Building():m_SittingRoom("客厅"),m_BedRoom("卧室"){
		
	}
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;     //卧室
};

//全局函数
static void goodGay(Building *building){
	cout << "好基友全局函数 正在访问：" << building->m_SittingRoom << endl;
	cout << "好基友全局函数 正在访问：" << building->m_BedRoom << endl;
}
static void test01(){
	Building building;
	goodGay(&building);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

119_37类和对象-友元-友元类

#include<iostream>
#include<string>
using namespace std;
class Building;
class GoodGay{
public:
	GoodGay();
	void visit();  //参观函数，访问Building中的属性
	Building *building;
};
class Building{
	//GoodGay类是本类的好朋友，可以访问本类的私有成员
	friend class GoodGay;
public:
	Building();
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;     //卧室
};
//类外写成员函数
Building::Building() :m_SittingRoom("客厅"), m_BedRoom("卧室"){

}
GoodGay::GoodGay(){
	//创建建筑物对象
	building = new Building;
}
void GoodGay::visit(){
	cout << "好基友类正在访问 ：" << building->m_SittingRoom << endl;
	cout << "好基友类正在访问 ：" << building->m_BedRoom << endl;
}
static void test01(){
	GoodGay gg;
	gg.visit();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

120_38类和对象-友元-成员函数做友元

#include<iostream>
#include<string>
using namespace std;
class Building;
class GoodGay{
public:
	GoodGay();
	void visit();  //让visit参观函数，访问Building中私有的成员
	void visit2(); //让visit2参观函数,不可以访问Building中私有的成员
	Building *building;
};
class Building{
	//告诉编译器  GooGay类下的visit成员函数作为本类的好朋友，可以访问私有成员
	friend void GoodGay::visit();
public:
	Building();
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;     //卧室
};
//类外写成员函数
Building::Building() :m_SittingRoom("客厅"), m_BedRoom("卧室"){

}
GoodGay::GoodGay(){
	//创建建筑物对象
	building = new Building;
}
void GoodGay::visit(){
	cout << "成员函数visit正在访问 ：" << building->m_SittingRoom << endl;
	cout << "成员函数visit正在访问 ：" << building->m_BedRoom << endl;
}
void GoodGay::visit2(){
	cout << "成员函数visit2正在访问 ：" << building->m_SittingRoom << endl;
	//cout << "成员函数visit正在访问 ：" << building->m_BedRoom << endl;
}
static void test01(){
	GoodGay gg;
	gg.visit();
	gg.visit2();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

121_39类和对象-C++运算符重载-加号运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另外一种功能，以适应不同的数据类型。
作用：实现两个自定义数据类型的相加
在这里插入图片描述

#include<iostream>
#include<string>
using namespace std;
//加号运算符重载
class Person{
public:
	//1、成员函数重载+号
	Person operator+(Person &p){
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}
	int m_A;
	int m_B;
};

//2、全局函数重载+号
Person operator+(Person &p1, Person &p2){
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
//函数的重载版本
Person operator+(Person &p1, int num){
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}
static void test01(){
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;
	//Person p3 = p1 + p2;
	//成员函数重载的本质调用
	Person p3 = p1.operator+(p2);
	//全局函数重载的本质调用
	Person p4 = operator+(p1, p2);
	//运算符重载，也可以发生函数重载
	Person p5 = p1 + 9 0;
	cout << "p3.m_A =" << p3.m_A << endl;
	cout << "p3.m_B =" << p3.m_B << endl;
	cout << "p4.m_A =" << p4.m_A << endl;
	cout << "p4.m_B =" << p4.m_B << endl;
	cout << "p5.m_A =" << p5.m_A << endl;
	cout << "p5.m_B =" << p5.m_B << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

总结1：对于内置的类型的表达式的运算符是不可能该笔那的
总结2：不能滥用运算符重载

122_40类和对象-C++运算符重载-左移运算符重载（！！）

作用：可以输出自定义数据类型

#include<iostream>
#include<string>
using namespace std;
//左移运算符重载
class Person{
	friend ostream& operator<<(ostream &cout, Person &p);
public:
	Person(int a, int b):m_A(a),m_B(b){
		
	}
private:
	//利用成员函数重载  左移运算符  p.operator<<(cout) 简化版本 p << cout
	//不会利用成员函数重载<< 运算符，因为无返实现cout在左侧
	//void operator<<(cout){

	//}
	int m_A;
	int m_B;
};
//只能利用全局函数重载左移运算符
static ostream& operator<<(ostream &cout, Person &p)    //本质 operator<<(cout ,p)  简化 cout << p
{
	cout << "m_A" << p.m_A << "\tm_B =" << p.m_B;
	return cout;
}
static void test01(){
	Person p(10,20);
	cout << p << "  Hello World"<<endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：重载左移运算符配合友元可以实现输出自定义类型的数据类型

123_41类和对象-C++运算符重载-递增运算符重载（！！）

作用：通过重载递增运算符，实现自己的整型数据

#include<iostream>
#include<string>
using namespace std;
//重载递增运算符
//自定义整型
class MyInteger{
	friend ostream &operator<<(ostream&cout, MyInteger myint);
public:
	MyInteger() :m_Num(0){

	}
	//重载前置++运算符
	MyInteger& operator++(){  //返回引用为了一直对一个数据进行递增操作
		//先进行++运算
		m_Num++;
		//再将自身做返回
		return *this;
	}
	//重载后置++运算符
	//int 代表占位参数，可以用于区分前置和后置递增
	MyInteger operator++(int){
		//先  返回结果
		MyInteger temp = *this;
		//后  递增
		m_Num++;
		//最后将记录的结果返回
		return temp;
	}
private:
	int m_Num;
};
//重载左移<<运算符
static ostream &operator<<(ostream&cout, MyInteger myint){
	cout << myint.m_Num;
	return cout;
}
static void test01(){
	MyInteger myint;

	cout << ++(++myint) << endl;
	cout << myint << endl;
}
static void test02(){
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}
int main()
{
	test02();
	system("pause");
	return 0;
}

124_42类和对象-C++运算符重载-赋值运算符重载

C++编译器至少给一个类添加4个函数

默认构造函数（无参，函数体为空）
默认析构函数（无参，函数体为空）
默认拷贝构造函数，对属性进行值拷贝
赋值运算 operator=，对属性进行值拷贝
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

#include<iostream>
#include<string>
using namespace std;
//赋值运算符重载
class Person{
public:
	Person(int age){
		m_Age = new int(age);
	}
	~Person(){
		if (m_Age != nullptr){
			delete m_Age;
			m_Age = nullptr;
		}
	}
	//重载 赋值运算符
	Person& operator=(Person&p){
		//编译器是提供浅拷贝
		//m_Age = p.m_Age;
		//应该先判断是否有属性在堆区，如果有先释放干净，然后再深拷贝
		if (m_Age != nullptr){
			delete m_Age;
			m_Age = nullptr;
		}
		//深拷贝
		m_Age = new int(*p.m_Age);
		//返回对象本身
		return *this;
	}
	int *m_Age;
};

static void test01(){
	Person p1(18);
	Person p2(20);
	Person p3(30);
	
	p2 = p1;       //赋值操作
	p3 = p2 = p1;
	cout << "p1的年龄为：" << *p1.m_Age << endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

125_43类和对象-C++运算符重载-关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

#include<iostream>
#include<string>
using namespace std;
//重载的关系运算符
class Person{
public:
	Person(string name, int age):m_Name(name),m_Age(age){

	}
	//重载 ==号
	bool operator==(Person &p){
		if (this->m_Name == p.m_Name &&this->m_Age == p.m_Age){
			return true;
		}
		return false;
	}
	//重载 !=号
	bool operator!=(Person&p){
		if (this->m_Name != p.m_Name || this->m_Age != p.m_Age){
			return true;
		}
		return false;
	}
	string m_Name;
	int m_Age;
};

static void test01(){
	Person p1("Tom", 18);
	Person p2("Tom", 18);
	if (p1 == p2){
		cout << "p1 和 p2是相等的！！！" << endl;
	}
	else{
		cout << "p1 和 p2是不相等的！！！" << endl;
	}
	if (p1 != p2){
		cout << "p1 和 p2是不相等的！！！" << endl;
	}
	else{
		cout << "p1 和 p2是相等的！！！" << endl;
	}
}
int main()
{
	test01();
	system("pause");
	return 0;
}

126_44类和对象-C++运算符重载-函数调用运算符重载

函数调用运算符() 也可以重载
由于重载后使用的方式非常像函数的调用，因此称为仿函数
仿函数没有固定的写法，非常灵活

#include<iostream>
#include<string>
using namespace std;
//函数调用运算符重载
//打印输出类
class MyPrint{
public:
	//重载函数调用运算符
	void operator()(string test){
		cout << test << endl;
	}
};

static void MyPrint2(string test){
	cout << test << endl;
}
static void test01(){
	MyPrint myPrint;
	myPrint("Hello World!!!"); //由于使用起来非常类似与函数调用，因此称为仿函数
	MyPrint2("Hello world!!!!!!!");
}

//仿函数非常灵活，没有固定的写法
//加法类
class MyAdd{
public:
	int operator()(int num1, int num2){
		return num1 + num2;
	}
};
static void test02(){
	MyAdd myadd;
	int ret = myadd(100, 200);
	cout << "ret = " << ret << endl;
	//匿名函数对象
	cout << MyAdd()(200, 300) << endl;
}
int main()
{
	test02();
	system("pause");
	return 0;
}

127_45类和对象-继承-基本语法

继承是面向对象的三大特征之一
利用继承的技术，减少重复代码
菜鸟代码

#include<iostream>
#include<string>
using namespace std;
//普通实现页面
//Java 页面
class Java{
public:
	void header(){
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footer(){
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left(){
		cout << "Java、Python、C++、...(公共分类列表)" << endl;
	}
	void content(){
		cout << "Java学科视频" << endl;
	}
};
//Python 页面
class Python{
public:
	void header(){
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footer(){
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left(){
		cout << "Java、Python、C++、...(公共分类列表)" << endl;
	}
	void content(){
		cout << "Python学科视频" << endl;
	}
};
//Cpp 页面
class Cpp{
public:
	void header(){
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footer(){
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left(){
		cout << "Java、Python、C++、...(公共分类列表)" << endl;
	}
	void content(){
		cout << "Cpp学科视频" << endl;
	}
};


static void test01(){
	Java java;
	cout << "--------------------Java 浏览界面---------------------" << endl;
	java.header(), java.footer(), java.left(), java.content();
	Python python;
	cout << "--------------------Python 浏览界面---------------------" << endl;
	python.header(), python.footer(), python.left(), python.content();
	Cpp cpp;
	cout << "--------------------Cpp 浏览界面---------------------" << endl;
	cpp.header(), cpp.footer(), cpp.left(), cpp.content();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

利用继承的方式写
继承的好处：减少重复代码
语法：class 子类：继承方式父类

#include<iostream>
#include<string>
using namespace std;
//继承实现页面
class BasePage{
public:
	void header(){
		cout << "首页、公开课、登录、注册...(公共头部)" << endl;
	}
	void footer(){
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	void left(){
		cout << "Java、Python、C++、...(公共分类列表)" << endl;
	}
};
//Java 页面
class Java :public BasePage{
public:
	void content(){
		cout << "Java 学科视频" << endl;
	}
};
//Python 页面
class Python :public BasePage{
public:
	void content(){
		cout << "Python 学科视频" << endl;
	}
};
//Cpp 页面
class Cpp :public BasePage{
public:
	void content(){
		cout << "Cpp 学科视频" << endl;
	}
};
static void test01(){
	Java java;
	cout << "--------------------Java 浏览界面---------------------" << endl;
	java.header(), java.footer(), java.left(), java.content();
	Python python;
	cout << "--------------------Python 浏览界面---------------------" << endl;
	python.header(), python.footer(), python.left(), python.content();
	Cpp cpp;
	cout << "--------------------Cpp 浏览界面---------------------" << endl;
	cpp.header(), cpp.footer(), cpp.left(), cpp.content();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述

128_46类和对象-继承-继承方式

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

公共继承
保护继承
私有继承

在这里插入图片描述

#include<iostream>
#include<string>
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 = 10;   //父类中的公共权限成员，到子类中依然是公共权限
		m_B = 10;   //父类中的保护权限成员，到子类中依然是保护权限
		//m_C = 10; //父类中的私有权限成员，子类访问不到
	}
};

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

class Son2 :protected Base1{
public:
	void func(){
		m_A = 10;   //父类中的公共权限成员，到子类中是保护权限
		m_B = 10;   //父类中的保护权限成员，到子类中依然是保护权限
		//m_C = 10; //父类中的私有权限成员，子类访问不到
	}
};

static void test02(){
	Son2 s1;
	//s1.m_A = 100;   //在Son2中 m_A变为保护权限，因此类外不可访问
	//s1.m_B = 1000;  //在Son2中 m_B保护权限不可访问
}

//私有继承
class Son3 :private Base1{
public:
	void func(){
		m_A = 10;   //父类中的公共权限成员，到子类中是私有权限
		m_B = 10;   //父类中的保护权限成员，到子类中是私有权限
		//m_C = 10; //父类中的私有权限成员，子类访问不到
	}
};
int main()
{
	system("pause");
	return 0;
}

129_47类和对象-继承-继承中的对象模型

问题：从父类继承过来的成员，那些属于子类对象中？

#include<iostream>
#include<string>
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;
};
static void test01(){
	//在父类中的所有非静态成员属性都会被子类继承下去
	//父类中私有成员属性是被编译器给隐藏了，因此访问不到，但是确实继承下去了
	cout << "sizeof(Son) = " << sizeof(Son) << endl;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

利用开发人员命令提示工具查看对象模型
跳转盘符 F:
转到文件路径 cd 具体路径下
查看命名
cl /d1 reportSingleClassLayout类名文件名
在这里插入图片描述

130_48类和对象-继承-构造和析构的顺序

子类继承父类后，当创建子类对象，也会调用到父类的构造函数
问题：父类和子类的构造和析构顺序是谁先谁后的？

#include<iostream>
#include<string>
using namespace std;

//继承中的构造和析构
class Base{
public:
	Base(){
		cout << "Base的构造函数！" << endl;
	}
	~Base(){
		cout << "Base的析构函数！" << endl;
	}
	int m_Age;
};
class Son :public Base{
public:
	Son(){
		cout << "Son的构造函数！" << endl;
	}
	~Son(){
		cout << "Son的析构函数！" << endl;
	}
};
static void test(){
	//Base b;
	Son s;
}
int main()
{
	test();
	system("pause");
	return 0;
}

继承中的构造函数和析构函数顺序如下：
先构造父类，再构造子类，析构的顺序与构造的顺序相反
在这里插入图片描述

131_49类和对象-继承-同名成员处理

问题：当子类和父类同时出现同名的成员，如何通过子类对象，访问到子类或父类中的同名的数据呢？

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

#include<iostream>
#include<string>
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;
};
static void test(){
	Son s;
	cout << "m_A = " << s.m_A << endl;
	//如果通过子类对象访问到父类中同名成员，需要加作用域
	cout << "m_A = " << s.Base::m_A << endl;
}
static void test01(){
	Son s;
	s.func();
	//如果通过子类对象访问到父类中的同名成员函数，需要加作用域
	s.Base::func();
	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名的成员函数
	//如果想要访问到父类中的隐藏的同名成员函数，需要加作用域
	s.Base::func(100);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

总结：

子类对象可以直接访问到子类中的同名成员
子类对象加作用域可以访问到父类中同名的函数
当子类域父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数。

132_50类和对象-继承-同名静态成员处理

问题：继承中同名的静态成员在子类对象上如何进行访问？
静态成员和非静态成员出现同名，处理方式一致

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

#include<iostream>
#include<string>
using namespace std;
//继承中的同名静态成员处理方式
class Base{
public:
	static int m_A;
	static void func(){
		cout << "Base - static void func()" << endl;
	}
};
//静态成员的属性
//1、编译阶段分配内存，所有对象共享同一份数据
//2、类内声明，类外初始化
int Base::m_A = 200;
class Son :public Base{
public:
	static int m_A;
	static void func(){
		cout << "Son - static void func()" << endl;
	}
};
int Son::m_A = 100;
//同名的静态成员属性
static void test(){
	//1、通过对象访问
	cout << "1、通过对象访问" << endl;
	Son s;
	cout << " Son m_A = " << s.m_A << endl;
	cout << " Base m_A = " << s.Base::m_A << endl;
	//2、通过类名访问
	cout << "2、通过类名访问" << endl;
	cout << "Son下m_A =" << Son::m_A << endl;
	cout << "Base下m_A = " << Son::Base::m_A << endl;
}
//同名的静态成员函数
static void test01(){
	//1、通过对象访问
	cout << "1、通过对象访问" << endl;
	Son s;
	s.func();
	s.Base::func();
	//2、通过类名访问
	cout << "2、通过类名访问" << endl;
	Son::func();
	Son::Base::func();

}
int main()
{
	test01();
	system("pause");
	return 0;
}

133_51类和对象-继承-继承语法

C++允许一个类继承多个类
语法：class 子类：继承方式父类1，继承方式父类2…
多继承可能会引发父类中有同名成员出现，需要加作用域区分
C++实际开发中不建议用多继承

#include<iostream>
#include<string>
using namespace std;
//多继承语法
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;
};
static void test(){
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	//当父类中出现了同名的成员，需要加作用域区分
	cout << " Base1 m_A = " << s.Base1::m_A << endl;
	cout << " Base2 m_A = " << s.Base2::m_A << endl;
}
int main()
{
	test();
	system("pause");
	return 0;
}

在这里插入图片描述

134_52类和对象-继承-菱形继承问题以及解决方法

菱形继承概念：
两个派生类继承同一个基类
又有某个类同时继承这两个派生类
这种继承被称为菱形继承，或者钻石继承
在这里插入图片描述
菱形继承问题：

羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性
草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

#include<iostream>
#include<string>
using namespace std;
//动物类
class Animal{
public:
	int m_Age;
};
//利用虚继承 解决菱形继承的问题
//继承之前，加上关键字 virtual变为虚继承
//Animal类称为 虚基类
//羊类
class Sheep :virtual public Animal{

};
//驼类
class Tuo :virtual public Animal{

};
//羊驼类
class SheepTuo :public Sheep, public Tuo{

};

static void test01(){
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 20;
	//当菱形继承，两个父类拥有相同数据，需要加作用于区分
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
	//这份数据我们知道 只有一份就可以，菱形继承导致数据有两份，资源浪费
}
int main()
{
	test01();
	system("pause");
	return 0;
}

在这里插入图片描述
vbptr
v - virtual
b - base
ptr - point

总结：
菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
利用虚继承可以解决菱形继承问题

135_53类和对象-多态-多态的基本语法

多态是C++面向对象的三大特殊之一
多态分为两类：

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态
静态多态和动态多态的区别：
静态多态的函数地址早绑定 - 编译阶段确定函数阶段
动态多态的函数地址晚绑定-运行阶段确定函数地址

#include<iostream>
#include<string>
using namespace std;
class Animal{
public:
	virtual void speak(){
		cout << "动物在说话：" << endl;
	}
};
class Cat :public Animal{
public:
	void speak(){
		cout << "小猫在喵喵叫" << endl;
	}
};

//执行说话的函数
//地址早绑定  在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定，地址晚绑定

//动态多态的满足条件
//1、有继承关系
//2、子类重新父类的虚函数
//动态多态的使用
//父类的指针或引用指向子类对象
static void doSpeak(Animal &animal){  //Animal& animal = cat;
	animal.speak();
}
static void test01(){
	Cat cat;
	doSpeak(cat);
}
int main()
{
	test01();
	system("pause");
	return 0;
}

//动态多态的满足条件
//1、有继承关系
//2、子类重新父类的虚函数
//动态多态的使用
//父类的指针或引用指向子类对象

136_54类和对象-多态-多态的原理剖析

在这里插入图片描述

137_55类和对象-多态-案例1-计算器类

案例描述：
分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
多态的优点：

代码组织结构清晰
可读性强
利于前期和后期的扩展以及维护

#include<iostream>
#include<string>
using namespace std;
//分别利用普通写法和多态技术实现计算器
//普通写法
class Calculator{
public:
	int getResult(string oper){
		if (oper == "+"){
			return m_Num1 + m_Num2;
		}
		else if (oper == "-"){
			return m_Num1 - m_Num2;
		}
		else if (oper == "*"){
			return m_Num1 * m_Num2;
		}
		//如果想要扩展新功能，需要修改源码
		//在真实的开发中，提出开闭原则
		//开闭原则：对扩展进行开发，对修改进行关闭
	}
	int m_Num1, m_Num2;
};

static void test01(){
	Calculator c1;
	c1.m_Num1 = 10;
	c1.m_Num2 = 20;
	cout << c1.m_Num1 << "+" << c1.m_Num2 << "=" << c1.getResult("+") << endl;
	cout << c1.m_Num1 << "-" << c1.m_Num2 << "=" << c1.getResult("-") << endl;
	cout << c1.m_Num1 << "*" << c1.m_Num2 << "=" << c1.getResult("*") << endl;
}

//利用多态实现计算器
//多态带来的好处：
//1、组织结构清晰
//2、可读性强
//3、对于前期和后期的维护性强
//实现计算器抽象类
class AbstractCalculator{
public:
	virtual int getResult() = 0;
	int m_Num1, m_Num2;
};
//实现加法
class AddCalculator:public AbstractCalculator{
public:
	int getResult(){
		return m_Num1 + m_Num2;
	}
};
//实现减法
class SubCalculator:public AbstractCalculator{
public:
	int getResult(){
		return m_Num1 - m_Num2;
	}
};
//实现乘法
class MulCalculator :public AbstractCalculator{
public:
	int getResult(){
		return m_Num1 * m_Num2;
	}
};
static void test02(){
	//多态的使用条件
	//父类的指针或引用指向子类的对象
	//加法运算
	AbstractCalculator *abc = new AddCalculator;
	abc->m_Num1 = 10, abc->m_Num2 = 20;
	cout << abc->m_Num1 << "+" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;
	//减法运算
	abc = new SubCalculator;
	abc->m_Num1 = 10, abc->m_Num2 = 20;
	cout << abc->m_Num1 << "-" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;
	//乘法运算
	abc = new MulCalculator;
	abc->m_Num1 = 10, abc->m_Num2 = 20;
	cout << abc->m_Num1 << "*" << abc->m_Num2 << "=" << abc->getResult() << endl;
	//用完后记得销毁
	delete abc;
}
int main()
{
	test02();
	system("pause");
	return 0;
}

总结：C++开发提倡利用多态设计程序架构，因为多态优点很多

138_56类和对象-多态-纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型函数名（参数列表） = 0；
当类中有了纯虚函数，这个类也称为抽象类
抽象类的特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类

#include<iostream>
#include<string>
using namespace std;
//纯虚函数和抽象类
class Base{
public:
	//纯虚函数
	//只要有一个纯虚函数，这个类称为抽象类
	//抽象类的特点：
	//1、无法实例化对象
	//2、抽象类的子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void func() = 0;
};
class Son :public Base{
public:
	virtual void func(){
		cout << "func 函数的调用" << endl;
	}
};

static void test01(){
	//Base b;    //抽象类是无法实例化对象
	//new Base;  //抽象类是无法实例化对象
	Son s;       //子类必须重写父类的纯虚函数，否则无法实例化对象
	Base *base = new Son;
	base->func();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

139_57类和对象-多态-案例2-制作饮品

案例描述：
制作饮品的大致流程为：煮水-冲泡-倒入杯中-加入佐料
利用多态技术实现本案例，提供抽象制作饮品基类，提供子类制作咖啡和茶叶
在这里插入图片描述

#include<iostream>
#include<string>
using namespace std;
//多态  案例2制作饮品
class AbstractDrinking{
public:
	//煮水
	virtual void Boil() = 0;
	//冲泡
	virtual void Brew() = 0;
	//倒入杯中
	virtual void PourInCup() = 0;
	//加入辅料
	virtual void PutSomething() = 0;
	//制作饮品
	void makeDrink(){
		Boil(), Brew(), PourInCup(), PutSomething();
	}
};
class Coffee :public AbstractDrinking{
public:
	//煮水
	virtual void Boil(){
		cout << "煮农夫山泉" << endl;
	}
	//冲泡
	virtual void Brew() {
		cout << "冲泡咖啡" << endl;
	}
	//倒入杯中
	virtual void PourInCup() {
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething() {
		cout << "加入拿铁" << endl;
	}
};
class Tea :public AbstractDrinking{
public:
	//煮水
	virtual void Boil(){
		cout << "煮怡宝矿泉水" << endl;
	}
	//冲泡
	virtual void Brew() {
		cout << "冲泡茶叶" << endl;
	}
	//倒入杯中
	virtual void PourInCup() {
		cout << "倒入杯中" << endl;
	}
	//加入辅料
	virtual void PutSomething() {
		cout << "加入枸杞" << endl;
	}
};

//制作函数
static void doWork(AbstractDrinking *abs){
	abs->makeDrink();
	delete abs;
}

static void test(){
	doWork(new Coffee);
	cout << "-----------------------------------" << endl;
	doWork(new Tea);
}

int main()
{
	test();
	system("pause");
	return 0;
}

140_58类和对象-多态-虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都需要有具体的函数实现
虚析构和纯虚析构区别：
如果是纯虚析构，该类属于抽象类，无法实例化对象

#include<iostream>
#include<string>
using namespace std;
//虚析构和纯虚析构
class Animal{
public:
	Animal(){
		cout << "Animal构造函数调用" << endl;
	}
	//纯虚函数
	virtual void speak() = 0;
	//虚析构解决了父类指针释放子类对象时不干净的问题
	/*virtual ~Animal(){
		cout << "Animal虚析构函数调用" << endl;
	}*/
	//纯虚析构  需要声明也需要实现
	//有了纯虚析构之后，这个类也属于抽象类，无法实例化对象
	virtual ~Animal() = 0;
};
 Animal::~Animal(){
	 cout << "Animal纯虚析构函数调用" << endl;
}

class Cat :public Animal{
public :
	Cat(string name){
		cout << "Cat构造函数调用" << endl;
		m_Name = new string(name);
	}
	virtual void speak(){
		cout << *m_Name << "小猫在喵喵叫" << endl;
	}
	string *m_Name;
	~Cat(){
		if (m_Name != nullptr){
			cout << "Cat析构函数的调用" << endl;
			delete m_Name;
			m_Name = nullptr;
		}
	}
};

static void test(){
	Animal *animal = new Cat("Tom");
	animal->speak();
	//父类指针在析构的时候不会调用子类中的析构函数，导致子类如果有堆区的属性，出现内存泄露
	delete animal;
}
int main()
{
	test();
	system("pause");
	return 0;
}

总结：
1、虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
2、如果子类中没有堆区数据，可以不写为虚析构和纯虚析构
3、拥有纯虚析构的类也属于抽象类

141_59类和对象-多态-案例3-电脑组装需求分析

电脑主要组成部件为CPU(用于计算)、显卡(用于显示)、内存条(用于存储)
将每个零件封装出抽象基类，并且提供不同的厂商生产不同的零件，例如Intel厂商和Lenovo厂商。
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装三台不同的电脑进行工作
在这里插入图片描述

142_60类和对象-多态-案例3-电脑组装具体实现

#include<iostream>
#include<string>
using namespace std;
class CPU{
public:
	//抽象的计算
	virtual void calculate() = 0;
};
class VideoCard{
public:
	//抽象的显示函数
	virtual void display() = 0;
};
class Memory{
public:
	//抽象的存储函数
	virtual void storage() = 0;
};
//电脑类
class Computer{
public:
	Computer(CPU *cpu, VideoCard*vc, Memory *mem) :m_cpu(cpu), m_vc(vc), m_mem(mem){

	}
	~Computer(){
		//释放CPU零件
		if (m_cpu != nullptr){
			cout << "xigou ---" << endl;
			delete m_cpu;
			m_cpu = nullptr;
		}
		//释放VideoCard零件
		if (m_vc != nullptr){
			delete m_vc;
			m_vc = nullptr;
		}
		//释放Memory零件
		if (m_mem != nullptr){
			delete m_mem;
			m_mem = nullptr;
		}
	}

	//提供工作的函数
	void work(){
		m_cpu->calculate();
		m_vc->display();
		m_mem->storage();
	}
private:
	CPU *m_cpu;
	VideoCard *m_vc;
	Memory *m_mem;
};
//具体厂商
//IntelCPU
class IntelCPU :public CPU{
public:
	virtual void calculate(){
		cout << "IntelCPU开始计算了！！" << endl;
	}
};
//IntelVideoCard
class IntelVideoCard :public VideoCard{
public:
	virtual void display(){
		cout << "IntelVideoCard 显卡开始显示了！！" << endl;
	}
};
//IntelMemory
class IntelMemory :public Memory{
public:
	virtual void storage(){
		cout << "IntelMemory 内存开始存储了！！" << endl;
	}
};

//LenovoCPU
class LenovoCPU :public CPU{
public:
	virtual void calculate(){
		cout << "LenovoCPU开始计算了！！" << endl;
	}
};
//LenovoVideoCard
class LenovoVideoCard :public VideoCard{
public:
	virtual void display(){
		cout << "LenovoVideoCard 显卡开始显示了！！" << endl;
	}
};
//LenovoMemory
class LenovoMemory :public Memory{
public:
	virtual void storage(){
		cout << "LenovoMemory 内存开始存储了！！" << endl;
	}
};

static void test(){
	//第一台电脑的零件
	CPU *interlCpu = new IntelCPU;
	VideoCard*intelCard = new IntelVideoCard;
	Memory *intelMem = new IntelMemory;
	//创建第一台电脑
	cout << "-------创建第一台电脑---------" << endl;
	Computer *computrer1 = new Computer(interlCpu, intelCard, intelMem);
	computrer1->work();
	delete computrer1;
	cout << "-------创建第二台电脑---------" << endl;
	Computer *computrer2 = new Computer(new LenovoCPU, new LenovoVideoCard, new LenovoMemory);
	computrer2->work();
	delete computrer2;
}
int main()
{
	test();
	system("pause");
	return 0;
}

运行结果：
在这里插入图片描述

143_61C++文件操作-文本文件-写文件

文件操作
程序运行时产生的数据都属于临时数据，程序一旦运行结束会被释放
通过文件可以将数据持久化
C++中对文件操作需要包含头文件< fstream >
文件类型分为两种：
1、文本文件 -文件以文本的ASCII码形式存储在计算机中
2、二进制文件-文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它
操作文件的三大类：

ofstream：写操作
ifstream ：读操作
fstream ：读写操作
文本文件
写文件
写文件步骤如下：
1、包含头文件
#include< fstream>
2、创建流对象
ofstream ofs;
3、打开文件
ofs.open(“文件路径”,打开方式);
4、写数据
ofs << “写入数据”；
5、关闭文件
ofs.close

注意：文件打开方式可以配合使用，利用|操作符
例如：用二进制方式写文件 ios::binary |ios::out

#include<iostream>
#include<string>
#include<fstream>   //头文件包含
using namespace std;
//文本文件  写文件
static void test(){
	//1、包含头文件fstream
	//2、创建流对象
	ofstream ofs;
	//3、指定打开方式
	ofs.open("test.txt", ios::out);
	//4、写文件
	ofs << "一饮涤昏寐，情来郎爽满天地" << endl;
	ofs << "再饮清我神，忽如飞雨洒轻生" << endl;
	ofs << "三饮便的道，何须苦心破烦恼" << endl;
	//5、ofs 关闭文件
	ofs.close();
}
int main()
{
	test(); 
	system("pause");
	return 0;
}

在这里插入图片描述
总结：

文件操作必须包含头文件fstream
读文件可以利用ofstream,或者fstream类
打开文件时候需要指定操作文件的路径，以及打开方式
利用<< 可以向文件中写数据
操作完毕，要关闭文件

144_62C++文件操作-文本文件-读文件

读文件与写文件步骤相似，但是读取方式相对比较多
读文件步骤如下：
1、包含头文件
#include< sftream>
2、创建流对象
ifstream ifs;
3、打开文件并判断文件是否打开成功
ifs.open(“文件路径”,打开方式);
4、读数据
四种方式读取
5、关闭文件
ifs.close();

#include<iostream>
#include<string>
#include<fstream>
using namespace std;
static void test(){
	//1、包含头文件
	//2、创建流对象
	ifstream ifs;
	//3、打开文件  并判断是否打开成功
	ifs.open("test.txt", ios::in);
	if (!ifs.is_open()){
		cout << "文件打开失败" << endl;
		return;
	}
	//4、读数据
	//第一种
	/*char buf[1024] = { 0 };
	while (ifs >> buf){
		cout << buf << endl;
	}*/
	//第二种
	/*char buf[1024] = { 0 };
	while (ifs.getline(buf, sizeof(buf))){
		cout << buf << endl;
	}*/
	//第三种
	string str;
	while (getline(ifs, str)){
		cout << str << endl;
	}
	//第四种
	/*char c;
	while ((c = ifs.get())!= EOF){
		cout << c;
	}*/
	//5、关闭文件 
	ifs.close();
}
int main()
{
	test();
	system("pause");
	return 0;
}

在这里插入图片描述

145_63C++文件操作-二进制文件-写文件

以二进制的方式对文件进行读写操作
打开方式要指定为ios::binary
写文件
二进制方式写文件主要利用流对象调用成员函数write
函数原型：ostream& write(const char*buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数

#include<iostream>
#include<string>
#include<fstream>
using namespace std;
//二进制文件   写文件
class Person{
public:
	char m_Name[64];
	int m_Age;
};
static void test(){
	//1、包含头文件
	//2、创建流对象
	ofstream ofs("person.txt", ios::out | ios::binary);
	//3、打开文件
	//ofs.open("person.txt", ios::out | ios::binary);
	//4、写文件
	Person p = { "张三", 18 };
	ofs.write((const char *)&p, sizeof(Person));
	//5、关闭文件
	ofs.close();
}
int main()
{
	test();
	system("pause");
	return 0;
}

在这里插入图片描述

总结：

文件输出流对象可以通过write函数，以二进制方式写数据

146_64C++文件操作-二进制文件-读文件

二进制方式读文件主要利用流对象调用成员函数read
函数原型：istream& read(char *buffer,int len);
参数解释：字符指针buffer指向内存中一段存储空间，len是读写的字节数

#include<iostream>
#include<string>
#include<fstream>
using namespace std;
class Person{
public:
	char m_Name[64];
	int m_Age;
};
static void test(){
	//1、包含头文件
	//2、创建流对象
	ifstream ifs;
	//3、打开文件，判断文件是否打开成功
	ifs.open("person.txt", ios::in | ios::binary);
	if (!ifs.is_open()){
		cout << "文件打开失败" << endl;
		return;
	}
	//4、读文件
	Person p;
	ifs.read((char*)&p, sizeof(Person));
	cout << "姓名：" << p.m_Name << "年龄： " << p.m_Age << endl;
	//5、关闭文件
	ifs.close();
}
int main()
{
	test();
	system("pause");
	return 0;
}

在这里插入图片描述

yangyang_z

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
C++核心编程篇

C++核心编程084_01程序的内存模型-内存四区-代码区内存分区模型C++程序在执行时，将内存大方向划分为4给区域代码区：存放函数体的二进制代码，由操作系统进行管理的全局区：存放全局变量和静态变量以及常量栈区：由编译器自动分配释放，存放函数的参数值，局部变量等堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收内存四区意义：不同的区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程程序运行前在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域代码区：
复制链接

扫一扫