[C++知识库]【C++】类和对象 (上篇)

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

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题；而C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。我们以洗衣服为例。

面向过程 – 逐步求解问题：

面向对象 – 通过对象之间的交互解决问题：

又比如我们的外卖系统：面向过程关注的是顾客应该如何下单、商家应该如何做出菜品、骑手应该如何将外卖送达；而面向对象关注的是顾客、商家、骑手这四个对象之间的交互，比如顾客下单后商家出餐，然后骑手送餐，而不必关心顾客如何下单、商家如何出餐、骑手如何送达这类面向过程的问题。

二、类的引入

在C语言中我们学习了结构体，知道了结构体可以定义某一种类型，但是不能定义具体的对象；以下面的结构体为例：

struct Student
{
	char name[20];
	char id[11];
	int weight;
	int height;
};

int main()
{
	struct Student stu1 = { "zhangsan", "2202101001", 60, 180 };
}

struct Student 只是定义了学生这种类型，而我们需要用这种类型来创建出具体的学生，比如张三李四；在C++中，学生类型被简称为 “类”，而具体的学生则被称为 “对象”；

但是我们知道，一个对象除了具有自身的属性 (数据) 之外，还应该拥有相应的方法 (行为)，比如学生除了姓名、学号、体重、身高这些属性之外，还应该具有吃饭、睡觉、学习、娱乐等行为；

但是C语言结构体中只能定义变量，不能定义函数 (方法)，所以C++对C语言的结构体进行了升级 – 在C++中，结构体内不仅可以定义变量，也可以定义函数。比如，之前在数据结构初阶中，我们用C语言方式实现的栈，结构体中只能定义 top、capacity、a 这些变量，而入栈、出栈、初始化这些函数只能在结构体外部定义；而使用C++我们就可以直接将这些函数定义在结构体内部：

//成员函数与成员变量都定义在结构体中
struct Stack
{
	//成员函数
	//初始化
	void Init(int N = 4)  //缺省参数 -- 初始化空间大小
	{
		_data = (int*)malloc(sizeof(int) * N);
		if (_data == nullptr)
		{
			perror("malloc fail\n");
			exit(-1);
		}
		_top = 0;
		_capacity = N;
	}

	//入栈
	void Push(int x)
	{
		if (_top == _capacity)
		{
			int* tmp = (int*)realloc(_data, sizeof(int) * _capacity * 2);
			if (tmp == nullptr)
			{
				perror("realloc fail\n");
				exit(-1);
			}
			_data = tmp;
			_capacity *= 2;
		}
		_data[_top++] = x;
	}

	//取栈顶的数据
	int Top()
	{
		return _data[_top - 1];
	}

	//销毁栈
	void Destroy()
	{
		free(_data);
		_data = NULL;
	}

	//成员变量(属性)
	int* _data;
	int _top;
	int _capacity;
};

同时，C++结构体直接使用 structName 代表类，而不用加 struct 关键字，但是C++兼容C语言结构体的全部用法，使用我们使用 struct + structName 的方式定义变量也是没问题的：

typedef struct SListNode
{
	SListNode* next;  //SListNode 可以直接代表这个类，所以此处可以不用加 struct
	int data;
}SL;

int main()
{
	//C语言用法
	struct SListNode* sl1;
	SL* sl2;

	//C++用法
	SListNode* sl3;
}

最后，在C++中更喜欢用 class 来代替 struct，并且把变量称为属性/成员变量，把函数称为成员函数/成员方法。

三、类的定义

class className
{
	 //... 
};

class为定义类的关键字，ClassName 为类的名字，{} 中为类的主体，注意类定义结束时后面分号不能省略。类体中的内容称为类的成员：类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数；

类的定义方式

C++类一共有两种定义方式：

1、声明和定义全部放在类体中 (注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理) ：

2、类声明放在.h文件中，成员函数定义放在.cpp文件中 (注意：成员函数名前需要使用类名+域限定符)：

类定义的两个惯例

1、类的成员变量使用修饰符修饰 – 与C语言结构体不同，由于类中可以同时定义变量和函数，所以函数的形参与类成员变量就可能会发生冲突，这种情况在 Init 函数中十分常见，如下：

class Date
{
public:
	void Init(int year, int month, int day)
	{
		year = year;
		month = month;
		day = day;
	}

private:
	int year;
	int month;
	int day;
};

Init 函数的形参和类成员变量相同，这就导致我们初始化赋值的不确定性，当然我们也可以使用类名+域作用限定符或者this指针来解决这个问题：

void Init(int year, int month, int day)
{
    Date::year = year;
    Date::month = month;
    Date::day = day;
}

void Init(int year, int month, int day)
{
    this->year = year;
    this->month = month;
    this->day = day;
}

但是这样显然比较麻烦，所以在C++中有一个惯例 – 成员变量使用某种修饰符来修饰，其中常见的有四种：_menber、menber_、m_menber、mMenber，前面两种是在成员变量前/后加一个下划线_，第三种m_表示此变量是成员变量，最后一种m表示成员变量，然后不使用_，使用小驼峰；我习惯于第一种方式，所以可以看到我前面类中的成员变量都会有一个前_。

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

2、成员函数定义在成员变量前面 – C语言编译器寻找变量的规则是先到前面去找，然后再到全局去找，所以在C语言中变量必须定义在函数前面，才可以在函数中使用该变量；但是C++编译器不一样，C++编译器会把类看作一个整体，当我们使用一个变量时，它会到整个类中去寻找，然后再到全局去寻找；所以在C++中，我们是可以将成员变量定义成员函数后面的；

上面解释了成员函数定义在成员变量之前的可行性，下面我借用 《高质量C/C++编程》中的解释来阐述为什么要将成员函数定义在成员变量前面：

四、类的访问限定符及封装

访问限定符

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

访问限定符说明：

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

访问限定符的存在使得用户不能直接修改类中的成员变量，而是只能使用我们提供的特定接口，让类中的数据更加安全，也让用户使用类的方式更加规范。

注意：访问修饰限定符限定的只是类外的访问权限，类内可以随意访问；并且访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别。

面试题

问题：C++中 struct 和 class 的区别是什么？

回答：C++需要兼容C语言，所以C++中 struct 可以当成结构体使用；另外C++中 struct 还可以用来定义类，和class定义类是一样的，区别是 struct 定义的类默认访问权限是 public，class 定义的类默认访问权限是 private。(注意：在继承和模板参数列表位置上 struct 和 class 也有区别，只是我们暂时还没学习)

封装

面向对象有很多特性，其中最出名的是：封装、继承和多态；在类和对象阶段，我们主要研究类的封装特性，那什么是封装呢？

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

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

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

在数据结构初阶时，我们曾用C语言来实现栈，其中关于返回栈顶元素的函数接口 – Top就很好的体现了封装的作用：

由于C语言没有访问限定符，也没有封装的概念，所以对于取得栈顶元素就有了两种方法 ：一是通过Top函数接口，二是直接访问data数组；

但是这里就出现了一个问题 – 结构体成员top是指向栈顶，还是指向栈顶的下一个位置是不确定的，其取决于Init函数；当 top 被初始化为-1时，top指向栈顶元素；而当其被初始化为0时，则指向栈顶的下一个元素；

所以可能就会出现这样一种情况：用户没有使用Top函数提供的接口，而是直接访问data数组，导致取出的栈顶元素是一个随机值；这种情况在现实中是经常出现的，甚至在有的教材中都是如此；

但是C++就不会出现这种情况，因为C++类成员变量通常都会用 private 修饰，用户不能直接访问类中的数据，只能通过特定的接口 (用 public 修饰的函数) 来操作对象。

在我们现实生活中对于各种文化旅游景点的设置也体现了封装 – 文物用展柜封装起来，使得游客 (类外) 不能直接接触文物，只能是文物相关各种人员 (类内) 才能直接接触文物，从而即达到了观赏的目的，也避免了文物被破坏。

五、类的作用域

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

注意：类域和我们之前学习的命名空间域不同，命名空间域中存放的是变量和函数的定义，而类域中虽然可以定义函数，但对于变量来说，仅仅只是声明，并没有为变量开辟空间，只有用这个类实例化出的对象才会开辟空间；这也就是为什么结构体和类中的成员变量都不能直接初始化，而是必须先定义出变量的原因。

六、类的实例化

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

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

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

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

七、类对象模型

1、类对象的大小计算

在C语言阶段我们学习了如何计算一个结构体类型的大小，那么对于升级版的结构体 – 类来说，类中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？我们又如何计算一个类的大小？

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	char _a;
};

int main()
{
	cout << sizeof(A) << endl;
}

要想解决上面这两个问题，首先我们得明白类对象的存储方式。

2、类对象的存储方式

早期关于类对象的存储方式一共有三种设计方式；

方式一

对象中包含类的各个成员 – 成员变量与成员函数：

注：函数经过编译后变成一段指令，而这段指令并不存在于对象中，而是存在于一个公共区域 – 常量区 (代码段) 中；所以，同一个类实例化出的不同对象使用的是同一个函数，但是同一个类的不同对象不能共用同一个成员变量，因为每一个对象的成员变量的值都是不同的；另外，通常我们把这段指令中第一条指令的地址作为函数的地址，而类对象中存储的就是这个地址；

缺点：此方法虽然保存了该变量特有的成员变量的地址，但是调用同一份函数，如果按照此种方式存储，当一个类创建多个对象时，每个对象中都会保存一份函数的地址，相同地址保存多次，浪费空间。

方式二

成员变量全部保存，另外在对象中保存一份存放代码的区域的地址；也就是说，我们不单独保存每一个函数的地址，而是保存类中所有函数所在的代码段的起始地址，我们通过这地址就可以找到各个函数：

方式三

只保存成员变量的地址，不保存成员函数地址，成员函数直接到公共代码段中去寻找：

现在我们已经知道了方式一太浪费空间不可取，那么到底是采用方式二还是方式三呢？这取决于如果不存储代码段的起始地址，编译器能否找到函数。

实际上，由于函数经过编译后形成的指令是由编译器放置到代码段中去的，所以编译器在调用该函数时也能轻松的找到指令在代码段中所处的位置，并且编译器并也不会将不同类中成员函数所形成的指令混淆；

基于上面这个结论，方式二存储代码段的地址也显得浪费了，因为即使没有这个地址，我们也能高效准确的调用成员函数；所以最终我们选用方法三来存储类对象，即一个类的大小，实际就是该类中 ”成员变量” 之和。

我们可以通过下面这个例子来验证我们的结论：

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	char _a;
};

int main()
{
	cout << sizeof(A) << endl;
}

我们看到，类A的大小是1，说明只存储了成员变量 _a 的地址，而并没有存储成员函数 PrintA 的地址。

空类的大小

上面我们探讨的是普通类的大小，那么对于一些特殊的类，比如空类或者是只有成员函数，没有成员变量的类，他们的大小是多少呢？是0还是别的值？

class B
{
};

class C
{
	void PrintC()
	{
		cout << "PrintC()" << endl;
	}
	void InitC()
	{
		cout << "InitC()" << endl;
	}
};

int main()
{
	cout << sizeof(B) << endl;
	cout << sizeof(C) << endl;
}

我们可以看到，空类的大小为0，那么为什么不是1呢？因为当我们使用一个空类实例化多个对象时，需要用不同的空间来标识区分它们，所以编译器给了空类一个字节来唯一标识这个类的某一具体对象，该字节不存储有效数据。

3、结构体内存对齐规则

在明白了类对象的存储方式之后，我们就需要正式计算类对象的大小了，而类是由结构体演化而来的，并且类的成员函数还不进行存储，所以类大小的计算方式和结构体大小的计算方式完全相同，都需要进行内存对齐；

关于结构体内存对齐的详细知识我在C进阶部分已经发布过文章，所以这里就只简单罗列一下结构体内存对齐规则，关于细节有遗忘的老铁可以回头再复习一下：【C语言】自定义类型详解：结构体、枚举、联合

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

面试题

1、结构体怎么对齐？ 为什么要进行内存对齐？

2、如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？

3、什么是大小端？如何测试某台机器是大端还是小端？有没有遇到过要考虑大小端的场景？

上面这几个面试题在 【C语言】自定义类型详解：结构体、枚举、联合 中也有详细介绍，这里不再赘述。

八、this 指针

1、this 指针的引出

为了引出 this 指针，我们先来简略定义一个日期类 Date：

class Date
{
public:
	void Init(int year = 1970, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Init(2022, 10, 3);
	d1.Print();

	Date d2;
	d2.Init(2022, 10, 4);
	d2.Print();

	return 0;
}

对于上述类，有这样的一个问题：Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函
数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

实际上，C++中通过引入this指针解决该问题，即：C++编译器给每个 “非静态的成员函数“ 增加了一个隐藏的指针参数，让该指针指向当前对象 (函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问；只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

即上面的代码经过编译器处理后会变成下面这样：

class Date
{
public:
	void Init(Date* const this, int year = 1970, int month = 1, int day = 1)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

	void Print(Date* const this)
	{
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Init(&d1, 2022, 10, 3);
	d1.Print(&d1);

	Date d2;
	d2.Init(&d2, 2022, 10, 4);
	d2.Print(&d2);

	return 0;
}

但是 this 指针参数以及对象的地址都是由编译器自动传递的，当用户主动传递时编译器会报错；不过在成员函数内部我们是可以显示的去使用 this 指针的。

2、this 指针的特性

this 指针有如下特性：

• this 指针只能在 “成员函数” 的内部使用；
• this 指针使用 const 修饰，且 const 位于指针*的后面；即 this 本身不能被修改，但可以修改其指向的对象 (我们可以通过 this 指针修改成员变量的值，但不能让 this 指向其他对象)
• this 指针本质上是“成员函数”的一个形参，当对象调用成员函数时，将对象地址作为实参传递给 this 形参，所以对象中不存储this 指针；
• this 指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过建立“成员函数”的函数栈帧时压栈传递，不需要用户主动传递。(注：由于this指针在成员函数中需要被频繁调用，所以VS对其进行了优化，由编译器通过ecx寄存器传递)

3、相关面试题

1、this指针存在哪里？

答：this 指针作为函数形参，存在于函数的栈帧中，而函数栈帧在栈区上开辟空间，所以 this 指针存在于栈区上；不过VS这个编译器对 this 指针进行了优化，使用 ecx 寄存器保存 this 指针；

2、this 指针可以为空吗？

答：this 指针作为参数传递时是可以为空的，但是如果成员函数中使用到了 this 指针，那么就会造成对空指针的解引用；

3、下面这两个程序编译运行的结果分别是什么？

//下面两段程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A  //程序1
{
public:
    void Print()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}
//***********************************//
class A  //程序2
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

答：程序1正常运行。原因如下：

第一，虽然我们用空指针A访问了成员函数Print，但是由于成员函数并不存在于对象中，而是存在于代码段中，所以编译器并不会通过类对象p去访问成员函数，即并不会对p进行解引用；

第二，当对象是指针类型时，编译器会直接把这个指针作为形参传递给Print函数的 this 指针，而 this 作为参数传递是时可以为空的，在Print函数内部我们也并没有对 this 指针进行解引用。

程序2运行崩溃。原因如下：

程序2在 p->Print 处虽然可以正常运行，但是在Print函数内部，_a 会被转化为 this->_a，发生了空指针的解引用。

九、C语言和C++实现 Stack 的对比

1、C语言实现

typedef int DataType;
typedef struct Stack
{
	DataType* array;
	int capacity;
	int top;
}Stack;

void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = (DataType*)malloc(sizeof(DataType) * 4);
	if (NULL == ps->array)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	ps->capacity = 4;
	ps->top = 0;
}

void StackDestroy(Stack* ps)
{
	assert(ps);
	if (ps->array)
	{
		free(ps->array);
		ps->array = NULL;
		ps->capacity = 0;
		ps->top = 0;
	}
}

void CheckCapacity(Stack* ps)
{
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity * 2;
		DataType* temp = (DataType*)realloc(ps->array,newcapacity * sizeof(DataType));
		if (temp == NULL)
		{
			perror("realloc fail\n");
			exit(-1);
		}
		ps->array = temp;
		ps->capacity = newcapacity;
	}
}

void StackPush(Stack* ps, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->array[ps->top] = data;
	ps->top++;
}

int StackEmpty(Stack* ps)
{
	assert(ps);
	return 0 == ps->top;
}

void StackPop(Stack* ps)
{
	if (StackEmpty(ps))
		return;
	ps->top--;
}

DataType StackTop(Stack* ps)
{
	assert(!StackEmpty(ps));
	return ps->array[ps->top - 1];
}

int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}

int main()
{
	Stack s;
	StackInit(&s);
	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	StackPush(&s, 4);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));
	StackPop(&s);
	StackPop(&s);
	printf("%d\n", StackTop(&s));
	printf("%d\n", StackSize(&s));
	StackDestroy(&s);
	return 0;
}

可以看到，在用C语言实现时，Stack相关操作函数有以下共性：

• 每个函数的第一个参数都是Stack*；
• 函数中必须要对第一个参数检测，因为该参数可能会为NULL；
• 函数中都是通过Stack*参数操作栈的；
• 调用时必须传递Stack结构体变量的地址；

结构体中只能定义存放数据的结构，操作数据的方法不能放在结构体中，即数据和操作数据的方式是分离开的，而且实现上相当复杂一点，涉及到大量指针操作，稍不注意可能就会出错。

2、C++实现

typedef int DataType;
class Stack
{
public:
	void Init(int N = 4)
	{
		_array = (DataType*)malloc(sizeof(DataType) * N);
		if (NULL == _array)
		{
			perror("malloc fail\n");
			exit(-1);
		}
		_capacity = N;
		_top = 0;
	}

	void Push(DataType data)
	{
		CheckCapacity();
		_array[_top] = data;
		_top++;
	}

	void Pop()
	{
		if (Empty())
			return;
		_top--;
	}

	DataType Top()
	{
		return _array[_top - 1];
	}

	int Empty()
	{
		return 0 == _top;
	}

	int Size()
	{
		return _top;
	}

	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_top = 0;
		}
	}

	void CheckCapacity()
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* temp = (DataType*)realloc(_array, newcapacity *sizeof(DataType));
			if (temp == NULL)
			{
				perror("realloc fail\n");
				exit(-1);
			}
			_array = temp;
			_capacity = newcapacity;
		}
	}

private:
	DataType* _array;
	int _capacity;
	int _top;
};

int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	printf("%d\n", s.Top());
	printf("%d\n", s.Size());
	s.Pop();
	s.Pop();
	printf("%d\n", s.Top());
	printf("%d\n", s.Size());
	s.Destroy();
	return 0;
}

相比于C语言而言，C++中通过类可以将数据以及操作数据的方法进行完美结合，通过访问权限可以控制那些方法在类外可以被调用，即封装，在使用时就像使用自己的成员一样，更符合人类对一件事物的认知。

而且每个方法不需要传递 Stack* 的参数了，编译器编译之后该参数会自动还原，即C++中 Stack* 参数是编译器维护的，而C语言中则需要用户自己维护。