类与对象（上）

片头

嗨！大家好，今天我们来一起学习C++的类与对象，准备好了吗？我们开始咯！

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

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

比如洗衣服这个过程，我们可以拆分成以下几个步骤；

C++是基于面向对象的，关注的是对象 ，将一件事情拆分成不同的对象，靠对象之间的交互完成。

上图中，总共有4个对象：人、衣服、洗衣粉、洗衣机

整个洗衣服的过程：人将衣服放进洗衣机、倒入洗衣粉，启动洗衣机，洗衣机就会完成洗衣过程并且甩干

整个过程主要是：人、衣服、洗衣粉、洗衣机四个对象之间交互完成的。人不需要关心洗衣机具体是如何洗衣服的，是如何甩干的

C++认为万事万物皆为对象，都有其自己的属性和行为，例如：

人可以作为对象，属性有姓名、年龄、身高......行为有走、跑、跳、说话......

车也可以作为对象，属性有轮胎、方向盘、车灯......行为有载乘客、放音乐......

具有相同性质的对象，可以抽象为类，不同的人可以属于人类，车属于车类

类是C++的核心特性，通常被称为用户定义的类型，是一种封装了数据和函数的组合。

类中的数据称为成员变量，函数称为成员函数。

---

二、类的引入 

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

#include<iostream>
using namespace std;

typedef int DataType;

//C++兼容C中struct的用法
//C++升级struct升级成了类
//类和对象
//1个类 实例化 N个对象

//C++升级struct升级成了类
//1.类里面可以定义函数
//2.struct名称就可以代表类型

struct Stack {

	//成员函数
	void Init(int capacity = 4) {
		_array =(DataType*) malloc(sizeof(DataType) * capacity);
		if (_array == nullptr) {
			perror("malloc fail!\n");
			exit(1);
		}
		_capacity = capacity;
		_top = 0;
	}

	//成员函数
	void Push(int x) {
		//扩容
		_array[_top] = x;
		_top++;
	}

	//成员变量
	DataType* _array;
	int _capacity;
	int _top;
};

int main() {
	Stack s;		//创建一个栈s
	s.Init();		//将栈s初始化
	s.Push(1);		//往栈s中放入"1"
	s.Push(2);		//往栈s中放入"2"
	s.Push(3);		//往栈s中放入"3"
	s.Push(4);		//往栈s中放入"4"
	return 0;
}

另外的，在C语言中，结构体的类型名是包含struct的，但是在C++中类型名不包含struct，例如：

---

 三、类的定义

class className {

	//类体：由成员函数和成员变量组成

};//一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面的分号不能省略。

类体中内容称为类的成员，类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数。

类的两种定义方式：

1. 成员函数的声明和定义全部放在类体中（比如上面栈的定义）

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意：成员函数名前需要加类名:: 

（或者：成员函数的声明和定义分离，在头文件中定义类，函数的声明放在类体中，在源文件中定义接口函数）

或者（如下图所示）

一般情况下，更期望采用第二种方式。

需要注意的是：当我们定义了一个类的时候，就是创建了一个类作用域。使用第二种方法定义类时，要在成员函数名的前面加上类名和作用域限定符。

另外，成员变量在命名时，建议在前面加上一个下划线_，这样可以方便和传递过来的形参进行区分。

例如：

class Date {
	void Init(int year) {
		//这里的year是成员变量还是函数形参？
		year = year;
	}
	int year;
};

所以一般建议这样：

//所以一般建议这样：
class Date {
	void Init(int year) {
		_year = year;
	}
	int _year;
};

//或者这样:
class Date {
	void Init(int year) {
		mYear = year;
	}
	int mYear;
};
//其他方式也是可以的，根据自己的需求来选择

不过，在上面第二种类的定义方法中，我们去使用函数的时候会出现以下情况：

这就和C++的访问权限符有关

---

四、类的访问限定符

C++实现封装的方式：用类将对象的属性和方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

C++中有三种访问限定符：public（公有）、protected（保护）和private（私有）

其中，因为C++要兼容C语言，所以struct中的成员默认公有，而class中的成员默认私有，所以才会导致上面的情况

关于访问权限符的说明：

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问（此处protected和private是类似的）
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. 如果后面没有访问限定符，作用域就到 } 即类结束
5. class的默认访问权限为private，struct默认访问权限为public（因为struct要兼容C）

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

当我们将成员函数用public修饰后，就可以在类外访问它们了。

---

五、封装 

面向对象的三大特性：封装、继承、多态

在类和对象阶段，我们主要研究类的封装特性，那什么是封装呢？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件原件。

对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等等。用户只需知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。 

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，开放成员函数的权限以供使用。

六、类的作用域

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

#include<iostream>
using namespace std;

//在Person这个类里面定义成员变量和成员函数
class Person {
public:
	void PrintPersonInfo();
private:
	char _name[20];
	char _gender[3];
	int _age;
};

#include"person.h"
//这里需要指定PrintPersonInfo是属于Person这个类域
void Person::PrintPersonInfo() {
	cout << _name << " " << _gender << " " << _age << endl;
}

---

七、类的实例化

用类创建对象的过程，称为类的实例化

1.类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述学生的具体信息。

类就像谜语一样，对谜底来进行描述，谜底就是谜语的一个实例。

谜语：“弯弯一座桥，架在半天腰，七色排得巧，一会不见了”  谜底：彩虹

谜语：“绿娃娃，街上站，光吃饼干不吃饭”  谜底：邮箱

2.一个类可以实例化出多个对象，实例化出的对象，占用实际的物理空间，存储类成员变量

Person类是没有空间的，只有Person类实例化出的对象才有具体年龄。

3.打个比方。类实例化出对象就像现实中使用建筑设计图建造出的房子，类就像是设计图纸，只设计出需要什么东西，但是并没有实体的建筑存在。同样，类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间。

OK，我们这样就完成Person对象实例化啦！

---

八、类对象模型

8.1 如何计算类对象的大小

请问，Stack实例化出的对象应该是多大呢？

答案是12，据此我们可以推断出，类的大小也是遵守内存对齐规则的，并且只计算成员变量，不计算成员函数

8.2 类对象的存储方式

为什么计算类对象的大小时不包含成员函数呢？

同一个类的每个对象中成员变量的值是不一样的，所以需要独立存储。

但是每个对象调用的成员函数是一样的，如果把成员函数存储在对象中，占用对象的内存空间，就导致用一个类实例化出多个对象时，每个对象都会保存一份代码，相同代码保存多次，浪费内存空间。所以我们将成员函数存放在公共的代码段中。

我们再通过对下面的不同对象分别获取大小来分析下

//类中既有成员变量，又有成员函数
class A1 {
public:
	void f1(){}
private:
	int _a;
};

//类中仅有成员函数
class A2 {
public:
	void f2(){}
};

//类中什么都没有---空类
class A3 {

};

 答案是 4 ，1 ，1

 虽然一个类中只有成员函数，一个类中什么也没有，但是还是会分配1byte的内存空间用来占位，标识对象已被实例化出来了。这1byte不会存储有效数据。

结论：一个类的大小，实际就是该类中“成员变量”之和，当然要注意内存对齐。注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

8.3 结构体内存对齐规则

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

九、this指针

现在我们知道，在C++中成员变量和成员函数是分开存储的，那么当我们调用成员函数的时候，函数是怎么区分是哪个对象调用自己的呢？

C++中提供this指针来解决该问题，this指针指向调用函数的对象，并隐式传递给函数。

我们不能手动显式地在参数列表中添加this指针，编译器自己会完成

9.1 this指针的用途

 （1）当形参与成员变量同名时，可用this指针区分

（2）在类的非静态成员函数中返回对象本身

9.2 this指针的特性

（1）this指针本质是一个指针常量：const Type* const pointer，所以在成员函数中不能给this指针赋值

（2）this指针只能在非静态成员函数中使用，在全局函数、静态成员函数中都不能用

（3）this指针本质上是成员函数的形参，当对象调用成员函数时，编译器将对象地址作为实参传递给this形参，所以this指针不存储在对象中！

（4）this指针会因编译器不同而存储在不同的位置，通常存在栈中，vs上存储在ecx寄存器中

this指针可以为空吗？

Q1：下面这种情况，程序会报错、运行崩溃还是正常运行呢？

#include<iostream>
using namespace std;


class date {
public:
	void Func() {
		cout << "Func()" << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	date* p = nullptr;
	p->Func();

	return 0;
}

答案是：正常运行

下面这种情况呢？

#include<iostream>
using namespace std;

class date {
public:
	void Func() {
		cout << _year << endl;
		cout << _month << endl;
		cout << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main() {
	date* p = nullptr;
	p->Func();

	return 0;
}

答案是：运行崩溃

为什么第一个情况能正常运行，而第二个情况就会崩溃呢？

因为出现箭头并不一定会解引用，Func函数不在对象内部，也没有对空指针p进行解引用，所以可以正常运行；而第二种情况，_year相当于this->_year，_year存在this指向的对象空间上面，到this指向的空间找，this是空，所以运行崩溃。

是否解引用，取决于右边要访问的东西在不在对象内部，而不是根据符号判断。

片尾

今天我们学习了C++的类和对象（上），希望看完这篇文章能对友友们有所帮助！！！

求点赞收藏和关注！！！

谢谢大家！！！