【C++】核心编程--类与对象（持续更新）

文章目录

1. 封装
- 1.1封装的意义
- - 1.1.1封装意义一：属性和行为
  - 1.1.2封装的意义二：访问权限
- 1.2 struct和class的区别
- 1.3 成员属性设置为私有
2.对象特性
- 2.1 构造函数和析构函数
- 2.2构造函数的分类及调用
- 2.3 拷贝构造函数调用时机
- 2.4 构造函数调用规则
- 2.5深拷贝与浅拷贝（面试经典问题，也是常见的坑）
- 2.6 初始化列表
- 2.7类对象作为类的成员
- 2.8 静态成员
3.C++对象模型和this指针
- 3.1 成员变量和成员函数分开存储
- 3.2 this指针
- 3.3 空指针访问成员函数
- 3.4 const修饰成员函数
4. 友元
- 4.1全局函数做友元
- 4.2友元类
- 4.3成员函数做友元
5.C++运算符重载
- 5.1 加号运算符重载
- 5.2左移运算符重载
- 5.3 递增运算符重载
- 5.4 赋值运算符重载
- 5.5 关系运算符重载
- 5.6 函数调用运算符重载
6. 继承
- 6.1基本语法
- 6.2 继承方式
- 6.3 继承中的对象模型
- 6.4 继承中构造和析构顺序
- 6.5 同名成员的处理
- 6.6 同名静态成员处理
- 6.7多继承语法
7. 多态
- 7.1多态的基本概念和原理剖析
- 7.2 纯虚函数和抽象类
- 7.3 虚析构和纯虚析构

C++面向对象的三大特性：封装、继承、多态
C++认为万事万物都皆为对象，对象上有其属性和行为
例如：人可以作为对象：属性有姓名，年龄，身高，体重…行为有走、跑、吃饭、唱歌…
车也可以作为对象，属性有轮胎，方向盘，车灯…行为有载人、放音乐、放空调…
具有相同性质的对象，我们可以抽象为类，人属于人类，车属于车类

1. 封装

1.1封装的意义

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

1.1.1封装意义一：属性和行为

在设计类的时候，属性和行为写在一起，表现事物
语法 class 类名{ 访问权限：属性 / 行为 }；

示例1：设计一个圆类，求圆的周长

#include<iostream>
using namespace std;

//圆周率
const double PI = 3.14;
//class代表设计一个类，类后面紧跟着的就是类的名称
class Circle
{
	//访问权限
public:  //公共权限
	//属性
	int m_r;//半径
	//行为
	double calculateZC()
	{
		return 2 * PI * m_r;
	}
};
int main()
{
	//通过圆这个类  创建具体的圆
	Circle c1;
	//给圆对象的属性进行赋值
	c1.m_r = 10;
	//2*PI*10  = 62.8
	cout << "圆的周长是： " << c1.calculateZC() << endl;
	system("pause");
	return 0;
}

1.1.2封装的意义二：访问权限

类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
1.公共的 public
2.保护权限protected
3.私有权限private

//三种权限
//公共权限：public     成员类内可以访问   类外可以访问
//保护权限：protected  成员类内可以访问   类外不可以访问 儿子可以访问父亲中的保护内容
//私有权限：private	  成员类内可以访问   类外不可以访问 儿子不可以访问父亲中的私有内容

#include<iostream>
using namespace std;

class Person
{
public:  //公共权限
	string m_Name;//姓名

protected://保护权限
	string m_Car;//汽车
private:
     //私有权限
	int m_Password;//银行卡密码
public:
	void func()
	{
		m_Name = "张三";
		m_Car = "拖拉机";
		m_Password = 123456;
	}
};

int main()
{
	Person p1;

	p1.m_Name = "李四";
	//p1.m_Car = "奔驰";//保护权限内容，在类外访问不到
	//p1.m_Password = 123;//私有权限内容，在类外访问不到
	system("pause");
	return 0;
}

1.2 struct和class的区别

在C++中struct和class唯一的区别在于默认的访问权限不同
区别：
struct默认权限为公共
class默认权限为私有

#include<iostream>
using namespace std;

class C1
{
	int m_A;//默认权限是私有
};

struct C2
{
	int m_A;//默认权限是公共
};
int main()
{
	//struct和class的区别
	//struct默认权限是 公共public
	//class默认权限是  私有private
	C1 c1;
	C2 c2;
	c2.m_A = 100;
	system("pause");
	return 0;
}

1.3 成员属性设置为私有

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

2.对象特性

生活中我们买的电子产品后基本会有出厂设置，在某一天我们不用时候也会删除一些自己信息数据保证安全
C++中面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置

2.1 构造函数和析构函数

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

一个对象或者变量没有初始状态，对其使用后果是未知
同样的使用完一个对象或者变量，没有及时清理，也会造成一定的安全问题

C++利用构造函数和析构函数解决上述问题，这两个函数被编译器自动调用，完成对象初始化和清理工作。
对象的初始化和清理工作是编译器强制要求我们做的事情，因此如果我们不提供构造函数和析构函数，编译器会提供

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

构造函数语法： 类名（）{ }

构造函数，没有返回值也不写void
函数名称与类名相同
构造函数可以有参数，因此可以发生重载
函数在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次

析构函数语法： ~类名（）{ }

析构函数，没有返回值也不写void
函数名称与类名相同，在名称前加上符号~
构造函数不可以有参数，因此不可以发生重载
函数在调用对象时候会自动调用析构，无需手动调用，而且只会调用一次

#include<iostream>
using namespace std;
class Person
{
	//构造函数
	//1. 构造函数，没有返回值也不写void
	//2.  函数名称与类名相同
	//3. 构造函数可以有参数，因此可以发生重载
	//4. 函数在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次
public:
	Person()
	{
		cout << "Person 构造函数的调用" << endl;
	}

	//析构函数 进行清理的操作
	//	1. 析构函数，没有返回值也不写void
	//2.  函数名称与类名相同，在名称前加上符号~
	//3. 构造函数不可以有参数，因此不可以发生重载
	//4. 函数在调用对象时候会自动调用析构，无需手动调用，而且只会调用一次
	~Person()
	{
		cout << "Person 析构函数的调用" << endl;
	}
};
//构造和析构都是必须有的实现，如果我们自己不提供，编译器会提供一个空实现的构造和析构
void test01()
{
	Person p;//在栈上的数据，test01执行完毕后，释放这个对象
}

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

2.2构造函数的分类及调用

两种分类方式
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造

3种调用方式：
括号法
显示法
隐式转换法

#include<iostream>
using namespace std;
//构造函数的分类及调用
//分类
//按照参数分类  无参构造（默认构造）和有参构造
//按照类型分类  普通构造  拷贝构造
class Person
{
public:
	//构造函数
	Person()//无参
	{
		cout << "Person的无参构造函数调用" << endl;
	}
	Person(int a)//有参
	{
		age = a;
		cout << "Person的有参构造函数调用" << endl;
	}
	//拷贝构造函数
	Person(const Person &p)
	{
		//将传入的人身上的所有属性，拷贝到我身上
		age = p.age;
		cout << "Person的拷贝构造函数调用" << endl;
	}

	int age;
};

void test01()
{
	//1.括号法  常用
	Person p;//默认构造函数使用
	Person p2(10);//有参构造函数
	Person p3（p2）;//拷贝函数调用

	//注意事项
	// 调用默认构造函数时候，不要加（）因为下面一行代码，编译器会认为是函数的一个声明
	// cout<<"p2的年龄是： "<<p2.age<<endl;
	//2.显示法
	Person p1;
	Person p2 = Person(10);//有参构造
	Person p3 = Person(p2);

	//Person(10);  //匿名对象 特点：当前行执行结束之后，马上析构
	//3.隐式转换法
	Person p4 = 10;//	Person p4 = Person(10)
	Person p5 = p4;//Person p5 = Person p4

	//注意：不能利用拷贝构造函数  初始化匿名对象 编译器认为是对象声明

}
int main()
{
	test01;

	system("pause");
	return 0;
}

2.3 拷贝构造函数调用时机

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

2.4 构造函数调用规则

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

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

构造函数调用规则：
1.如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
2.如果用户定义拷贝构造函数，c++不会再提供其他构造函数

2.5深拷贝与浅拷贝（面试经典问题，也是常见的坑）

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

2.6 初始化列表

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

2.7类对象作为类的成员

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

2.8 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员
静态成员分为：
静态成员变量：1. 所有对象共享同一份数据 2.编译阶段分配内存3.类内声明，类外初始化
静态成员函数：1.所有对象共享同一个函数 2.静态成员函数只能访问静态成员变量

3.C++对象模型和this指针

3.1 成员变量和成员函数分开存储

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

3.2 this指针

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码
那么问题来了：这一块代码是如何区分那个对象和调用自己的呢?
c++通过特殊的对象指针，this指针，结局上述问题，this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针
this指针不需要定义，直接使用即可

this指针的用途

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

3.3 空指针访问成员函数

c++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针
如果用到this指针，需要加以判断保证代码的健壮性

3.4 const修饰成员函数

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

4. 友元

友元的目的就是让一个函数或者类访问另一个类中私有成员
友元的关键字为 friend

友元的三种实现方式
1.全局函数做友元
2.类做友元
3.成员函数做友元

4.1全局函数做友元

4.2友元类

4.3成员函数做友元

5.C++运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

5.1 加号运算符重载

实现两个自定义数据类型相加的运算

5.2左移运算符重载

可以输出自定义数据类型

5.3 递增运算符重载

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

5.4 赋值运算符重载

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

默认构造函数（无参，函数体为空）

默认析构函数（无参，函数体为空）
默认拷贝构造函数，对属性值进行拷贝
赋值运算符operator=，对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

5.5 关系运算符重载

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

5.6 函数调用运算符重载

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

6. 继承

继承是面向对象三大特性之一：
有些类与类之间存在特殊的关系，如图
在这里插入图片描述

6.1基本语法

继承的好处：可以减少重复的代码
class A:public B;
A类称为子类或者派生类；
B类称为父类或者基类；

派生类中的成员，分为两大部分：
一类是从基类继承过来的，一类是自己增加的成员
从基类继承过来的表现其共性，而新增的体现了其个性

6.2 继承方式

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

继承方式一共有3类
公共继承
保护继承
私有继承
在这里插入图片描述

6.3 继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？
父亲中的私有成员也是被子类继承下去了，只是被编译器隐藏后访问不到

6.4 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父亲的构造函数
问题;父类和子类的构造和析构顺序是谁先谁后？
继承中，先调用父类构造函数，再调用子类构造函数，析构顺序与构造顺序相反

6.5 同名成员的处理

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

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

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

6.6 同名静态成员处理

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

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

静态成员和非静态成员出现同名，处理方式一致，只不过有两种访问的方式（通过对象和通过类名）

6.7多继承语法

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

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

多继承可能会引发父类中有同名成员出现，子类使用时需要加作用域区分
C++实际开发中不建议用多继承

7. 多态

7.1多态的基本概念和原理剖析

多态是C++面向对象三大特性之一

多态分为两类：
静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态

静态多态和动态多态区别：

静态函数的函数地址早绑定：编译阶段确定函数地址
动态函数的函数地址晚绑定：运行阶段确定函数地址

多态满足条件：
3. 有继承关系
4. 子类重写父类中的虚函数

多态使用条件
父类指针或引用指向子类对象

重写：函数返回值类型函数名参数列表
//完全一致称为重写

7.2 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容
因此可以将虚函数改为纯虚函数

纯虚函数语法： virtual 返回值类型函数名 {参数列表} = 0；
当类中有了纯虚函数，这个类也称为抽象类

抽象类特点

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

7.3 虚析构和纯虚析构

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

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都需要有具体的函数实现

虚析构与纯虚析构区别：
如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法
virtual ~类名
纯虚析构语法
virtual ~类名（） = 0
类名：：~类名（）{ }

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