C++入门篇，类与对象（上篇）

CHAK&MING

已于 2023-01-20 11:59:16 修改

阅读量455

点赞数 1

分类专栏： C++ 文章标签： c++ 开发语言

于 2022-08-09 15:45:20 首次发布

本文链接：https://blog.csdn.net/CHAKMING1/article/details/126249203

版权

C++ 专栏收录该内容

20 篇文章 19 订阅

订阅专栏

C++入门篇——类与对象（上篇）

从这一篇章开始，接触到C++面向对象的知识，与C语言的面向过程进行对比，介绍类的定义和使用，以及类中最重要的this指针的原理。

1 面向过程和面向对象的初步认识

C语言是一门面向过程的语言，什么是面向过程，简单来说，就是关注的是过程，分析一个问题的步骤，然后使用函数对这些步骤进行逐步求解。

比如说，我们今天想吃一个番茄炒蛋这个菜，那么，就会按照以下的步骤去进行：

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E5ikzVTI-1660031024241)(C:\Users\17660\AppData\Roaming\Typora\typora-user-images\image-20220809135207030.png)]$

这样一步一步去完成一件事情或者任务的，就叫做过程，而C语言就是采用面向过程这一特性。

C++是一门面向对象的语言，什么是面向对象，简单来说，就是关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互来完成。

比如说，洗衣服这件事情，我们需要人、洗衣机、衣服、洗衣粉四样东西，每个东西都可以是一个对象。

整个过程，只需要人将衣服放入洗衣机，并加入洗衣粉，最后考洗衣机自己完成洗衣服的工作。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mQ4t82Ix-1660031024242)(C:\Users\17660\AppData\Roaming\Typora\typora-user-images\image-20220809135727718.png)]$

2 类的介绍

我们知道C语言有一个结构体，结构体里面存放的是变量，对变量进行封装后，又称为一个新的类型，称为自定义类型。

而C++中，结构体不仅可以定义变量，还可以定义函数。C语言中的结构体的关键字是struct类型，C++保留了原有的结构体，引入了新的关键字class，也称为类。比如，我们想自定义一个栈类型，栈包含了初始化、入栈、出栈、销毁等操作。而这些都可以封装在一个类里面，如下：

typedef int DataType;

class Stack
{
public:
	void Init(size_t capacity)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (_array == NULL)
		{
			perror("malloc failed");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	// ...
	// ...
public:
	DataType* _array;
	size_t _capacity;
	size_t _size;
};

3 类的定义

类的定义与C语言的结构体相似，可以存放变量和函数，并且在此基础上多了一个访问限定符的知识。

class className
{
public: // 公共权限
	// 函数
	// 变量
}; // 必须有分号

class是类的关键字，className是类的名字，{}内的是类的主体，最后必须要有分号结尾。类中的变量和函数，可以称为类的成员，类中的变量称为类的属性或者成员变量，类中的函数称为类的方法或者成员函数。

4 类的访问限定符和封装

4.1 访问限定符

C++实现封装的方式，用类将对象的属性和方法结合在一块，为了让对象更加完善，通过访问限定符的方式来对外提供接口来给用户使用。所以引出了三种访问限定符。

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aaePSiGb-1660031024243)(C:\Users\17660\AppData\Roaming\Typora\typora-user-images\image-20220809141141067.png)]$

访问限定符的说明：

public修饰的成员在类外可以直接被访问
protected和private修饰的成员只能在类内访问，类外不可以访问，这两个的区别只有在继承时才有区别。
访问权限的作用域在访问限定符出现后一直到下一个访问限定符的区域。如果后面没有下一个访问限定符，就到类的作用域结束。
class默认所有成员均是私有成员，struct默认所有成员均是共有成员，在C++中，两个关键字只有该区别。

4.2 封装

面向对象的三大特性分别是封装、继承、多态。

这里先着重介绍封装的概念，封装就是将数据和操作数据的方法进行有机结合，隐藏对象属性和实现细节，对外提供公共接口来和对象进行交互。

比如说，我们的主机，我们的用户其实并不用太关系一台主机里面的硬件是如何构成的，具体的电路是如何实现的，它对外暴露了一些接口，比如开机、USB接口、电源插口等等。如何对这台主机的硬件进行封装，也能够让用户去使用它。

而C++的类其实也是一种封装，类的变量就是一些属性，类的函数就是具体的使用方法，而访问限定符，就是表示该方法或者属性要隐藏还是暴露给用户。

5 类的作用域

类定义了一个新的作用域，类中的所有成员都是在类的作用域中。在类外定义成员时，需要指明使用了哪个类域。

class Person
{
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int _age;
};

// 在类外实现类中的方法，需要指明该函数是在哪个类中
void Person::PrintPersonInfo()
{
	cout << _name << " " << _gender << " " << _age;
}

6 类的实例化

用类类型去创建一个对象，我们称这是类的实例化。

类是对对象进行描述，定义一个类的时候，实际上并没有分配具体的内存空间，只有创建一个对象的时候，才会分配空间。类和对象之间的关系是什么，区别又是什么，这里通过一个学生的例子进行讲解。

比如，我们在入学的时候，学校会拿到我们学生的信息表，而这里的学生就是一个类，而具体的学生A、学生B分别就是一个对象。一个类可以实例化多个对象。

class Student
{
private:
	int num;
	char _name[20];
	int age;
};


int main()
{
	Student A;
	Student B;
}

7 类对象模型

如何计算类的对象的大小，我们知道C语言的结构体的大小，是计算结构体中变量的大小，再根据内存对齐，最后得到结构体的大小。但是一个类不仅包含变量，还包含成员函数，并且类需不需要也按照内存对齐的来进行分配呢？

7.1 类对象的存储方式的猜测

方式一：对象中包含类的各个成员

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bbJKlbQW-1660031024244)(C:\Users\17660\AppData\Roaming\Typora\typora-user-images\image-20220809143739897.png)]$

每个对象的成员变量是不相同的，但是函数都是调用同一份函数，如果按照该方式去存储对象，会造成每个对象中会保存同一份代码，这样会造成空间的浪费，所以，引出第二种方法。

方式二：代码只保存一份，在对象一个指向类成员函数的表的指针

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qOuxBE3I-1660031024245)(C:\Users\17660\AppData\Roaming\Typora\typora-user-images\image-20220809144443818.png)]$

这种方式还是会造成冗余的情况，毕竟每个对象都还需要存放一个指向类函数表的地址，我们可不可以只存放类中的成员变量呢，因此引出第三种方法。

方式三：只保存成员变量，成员函数存放在公共的代码段

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W59S8Fey-1660031024246)(C:\Users\17660\AppData\Roaming\Typora\typora-user-images\image-20220809145107608.png)]$

那么，我们实际会用到哪种方法呢，我们通过一个例子来观察。

// 类中既有成员变量，又有成员函数
class A1 {
public:
	void f1(){}
private:
	int _a;
};
// 类中仅有成员函数
class A2 {
public:
	void f2() {}
};
// 类中什么都没有---空类
class A3
{};

三个类的大小分别是：

sizeof(A1) : 4
sizeof(A2) : 1
sizeof(A3) : 1

结论：

我们实际上使用的是对象存储方式三，这种方式中，对象只存放成员变量的，将成员函数放在公共代码段，因此成员函数不会占用存储空间。
注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。
类实际上也要满足内存对齐的问题，与结构体内存对齐一致。

7.2 结构体内存对齐规则

第一个成员在与结构体偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
VS中默认的对齐数为8
结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是
所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

8 this指针

8.1 this指针的引出

首先，介绍this指针之前，我们编写一个Date日期类。

class Date
{
public:
	void Init(int year, int month, int day)
	{
		year = year;
		month = month;
		day = day;
	}
private:
	int year; // 年
	int month; // 月
	int day; // 日
};

int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	return 0;
}

通过这个例子，引出一个问题，这段代码其实是有问题的，看到Init成员函数，我们会发现这样的代码year = year;那么，这个year指的是形参的year还是Date的成员变量year呢？编译器其实隐含了一个this指针，这个指针指向当前对象，可以通过this指针找到该对象的成员变量。这个指针不需要去传递，编译器自动完成。正确的代码：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		this->year = year;
		this->month = month;
		this->day = day;
	}
private:
	int year; // 年
	int month; // 月
	int day; // 日
};

int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	return 0;
}

那么，我们再来修改这段代码，又会发现另外一个问题。

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
	int a;
};

int main()
{
	Date d1, d2;
	d1.Init(2022, 1, 11);
	d2.Init(2022, 1, 12);
	d1.Print();
	d2.Print();
	return 0;
}