【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装

这篇具有很好参考价值的文章主要介绍了【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

💞💞欢迎来到 Claffic 的博客💞💞

👉 专栏：《是C++，不是C艹》👈

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

前言：

在C++入门之后，就要进入C++的第一个核心：类与对象，这期带大家认识认识面向对象编程，访问限定符，封装以及 this 指针。

注：

你最好是学完了C语言，并学过一些初阶的数据结构。

(没有目录) ヽ(￣ω￣(￣ω￣〃)ゝ

Part1:面向过程？面向对象？

C语言是面向过程的编程语言，在C语言的学习阶段，相信大家都会有这样的感受：

为什么能直接用的东西不多，事先要造轮子？

对每个过程都要仔细考虑，这一步完不成就进行不了下一步；

这或许就是面向过程带来的特性吧，❓那么什么是面向过程呢？这里有个很好的例子🌰：

一说到点外卖，你肯定非常熟练了：

找到手机📱 --> 解锁手机 --> 打开某知名外卖app --> 找到想吃的外卖🍔🍟🍗🍜🍢🍰（这一步往往会难到一大部分童鞋）--> 下单 --> 等待用餐

🪄你关注的是点外卖的过程，这既是面向过程。

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

❓如果是面向对象呢？

再来看刚刚的例子：这个场景包含的主要对象是用户，骑手，平台和商家。

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

如图，简单展示了四个对象之间的交互关系

用户不需要关注平台是如何发送订单的，也不需要关注商家是如何备餐的，只需要完成交互即可。

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

Part2:何为类？

1.一个引子

❓在C语言中，结构体能实现集合不同类型的变量，那如果我在结构体中定义函数呢？

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

注：以上测试代码在 .c文件中

很明显C语言是不允许在结构体中定义函数类型的。

而我将 .c改为 .cpp后，就没有错误了：

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

这种结构体的定义，在C++中更喜欢用类来替代，那什么是类呢？下面有答案：

2.类的定义

直接上格式：

class className
{
     // 类体：由成员函数和成员变量组成
 
};   // 注意分号

🪄解释：

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

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

🌰下面举个例子，顺便介绍下类的两种定义方式：

第一种：

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

第二种：

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

🚨 注意：成员函数名前需要加类名

在项目实现中，推荐使用第二种定义方式。

Part3:有关类的探讨

1.认识封装

📢说到面向对象，理应想起它的三大特性：继承，封装，多态

这里先来认识封装：

封装：

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

封装本质上是一种管理，让用户更方便地使用类

🌰比如：

看看你的笔记本电脑💻，这是一个很复杂的设备，不过对你公开的只有屏幕，电源键，键盘，触控板以及各种接口（电源接口、USB接口、雷电接口、3.5mm耳机接口等等）；

通过这些有限的对象和接口，你就能完成与笔记本电脑的交互。但实际上呢，电脑的核心在CPU，显卡，内存等元件，你不必知道这些元件是如何工作的，你会开机，使用键盘鼠标就行了。

对与笔记本电脑内部的细节，已被厂商披上了外壳，将其隐藏起来，这既是封装。

在 C++ 语言中实现封装，可以 通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内 部实现细节，控制哪些方法可以在类外部直接被使用 。

❓那用什么来控制访问权限呢？就在下面的访问限定符：

2.访问限定符

在上面定义类的例子中，大家也注意到了：

❓public 和 private 是什么意思？

这就是访问限定符，它们决定了外部访问的权限。

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

🪄各个访问限定符的说明：

• public 修饰的成员在类外可以直接被访问；

• protected 和 private 修饰的成员在类外不能直接被访问 ( 此处 protected 和 private 是类似的 )；

• 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止；

• 如果后面没有访问限定符，作用域就到 } 即类结束；

• class的默认访问权限为 private ， struct 为 public ( 因为 struct 要兼容 C)。

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

3.类的作用域

🪄这一部分解释了为什么要使用 ::

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

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

4.类的实例化

对类的定义，只是创建了一个模型，并没有分配实际的内存空间；

如果我们直接访问类中的成员：
【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

❌可以看到，直接用类来访问成员是错误的

❓那正确的使用姿势是怎么样的呢？

那就是类的实例化，即用类类型创建对象的过程。

实例化出的对象，占用实际的物理内存，存储成员变量。

🌰例子：

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

有个很好的比方，类就像是房子的设计图纸，类实例化的对象就像现实中用设计图纸设计出的房子

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

4.类的大小

❓你是否有这样的疑问：类中既可以有成员变量，又可以有成员函数，那么一个类的对象包含了什么？如何计算一个类的大小？

我们通过实验来解决这个问题：

// 既有成员变量，又有成员函数
class A1
{
public:
	void Get_a1()
	{
		cout << _a << endl;
	}
private:
	int _a;
};

// 仅有成员变量
class A2
{
private:
	int _a;
};

// 仅有成员函数
class A3
{
public:
	void Get_a3()
	{
		;
	}
};

// 空类
class A4
{};

int main()
{
	cout << sizeof(A1) << endl;
	cout << sizeof(A2) << endl;
	cout << sizeof(A3) << endl;
	cout << sizeof(A4) << endl;

	return 0;
}

👁️‍🗨️输出结果：

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

🗡️我们初步推断：

一个类的大小，就是所有“成员变量”大小，不包含成员函数，空类大小是一个字节。

❓那如果有多个成员变量会怎么样？

class A5
{
private:
	int _a;
	char* _b;
	long long _c;
};

int main()
{
	cout << sizeof(A5) << endl;

	return 0;

👁️‍🗨️输出结果：

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

4 + 8 + 8 == 20鸭，为什么是24？

难道，跟结构体一样，也存在内存对齐？

没错，类的成员也遵循内存对齐原则，详见：

【C生万物】谈谈结构体的内存对齐_Claffic的博客-CSDN博客https://blog.csdn.net/Claffic/article/details/128648797📝总结：

一个类的大小，不包含成员函数，就是该类中所有成员变量的大小，注意内存对齐；

空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

Part4: this指针

1.一个引子

我们先来定义一个日期类：

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 main()
{
	Date d1, d2;
	d1.Init(2023, 5, 27);
	d2.Init(2023, 6, 7);
	d1.Print();
	d2.Print();

	return 0;
}

对于上述代码，你是否有这样的疑问：

❓Date 类中有 Init 与 Print 两个成员函数，函数体中并没有关于不同类的区分，那当 d1 调用 Init 函数时，该函数时如何区分是设置 d1 对象而不是 d2对象呢？

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针

针对这个问题，C++引入了 this 指针：

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

2. this指针的特性

不罗嗦了：

• this 指针的类型：类类型 * const ，即成员函数中，不能给 this 指针赋值；

• 只能在“ 成员函数 ” 的内部使用；

• this指针本质上是 “ 成员函数 ” 的形参 ，当对象调用成员函数时，将对象地址作为实参传递给 this 形参。所以对象中不存储 this 指针；

• this指针是 “ 成员函数 ” 第一个隐含的指针形参，一般情况由编译器通过 ecx 寄存器自动传递，不需要用 户传递；

• this指针存储在栈区。

【是C++，不是C艹】类与对象 | 认识面向对象 | 访问限定符 | 封装 | this指针 编译器处理成员函数隐含的 this 指针

3.C语言实现 Stack VS C++实现 Stack

C语言实现：

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

void StackInit(Stack* ps)
{
	assert(ps);
	ps->array = (DataType*)malloc(sizeof(DataType) * 3);
	if (NULL == ps->array)
	{
		assert(0);
		return;
	}
	ps->capacity = 3;
	ps->size = 0;
}
void StackDestroy(Stack * ps)
{
	assert(ps);
	if (ps->array)
	{
		free(ps->array);
		ps->array = NULL;
		ps->capacity = 0;
		ps->size = 0;
	}
}
void CheckCapacity(Stack* ps)
{
	if (ps->size == ps->capacity)
	{
		int newcapacity = ps->capacity * 2;
		DataType* temp = (DataType*)realloc(ps->array,
			newcapacity * sizeof(DataType));
		if (temp == NULL)
		{
			perror("realloc申请空间失败!!!");
			return;
		}
		ps->array = temp;
		ps->capacity = newcapacity;
	}
}
void StackPush(Stack* ps, DataType data)
{
	assert(ps);
	CheckCapacity(ps);
	ps->array[ps->size] = data;
	ps->size++;
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	return 0 == ps->size;
}
void StackPop(Stack* ps)
{
	if (StackEmpty(ps))
		return;
	ps->size--;
}
DataType StackTop(Stack* ps)
{
	return ps->array[ps->size - 1];
}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->size;
}

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 结构体变量的地址；

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

C++实现：

typedef int DataType;
class Stack
{
public:
	void Init()
	{
		_array = (DataType*)malloc(sizeof(DataType) * 3);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		_capacity = 3;
		_size = 0;
	}
	void Push(DataType data)
	{
		CheckCapacity();
		_array[_size] = data;
		_size++;
	}
	void Pop()
	{
		if (Empty())
			return;
		_size--;
	}
	DataType Top() { return _array[_size - 1]; }
	int Empty() { return 0 == _size; }
	int Size() { return _size; }
	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = NULL;
			_capacity = 0;
			_size = 0;
		}
	}
private:
	void CheckCapacity()
	{
		if (_size == _capacity)
		{
			int newcapacity = _capacity * 2;
			DataType* temp = (DataType*)realloc(_array, newcapacity *
				sizeof(DataType));
			if (temp == NULL)
			{
				perror("realloc申请空间失败!!!");
				return;
			}
			_array = temp;
			_capacity = newcapacity;
		}
	}
private:
	DataType * _array;
	int _capacity;
	int _size;
};

int main()
{
	Stack s;
	s.Init();
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);

	cout << s.Top() << endl;
	cout << s.Size() << endl;

	s.Pop();
	s.Pop();

	cout << s.Top() << endl;
	cout << s.Size() << endl;

	s.Destroy();

	return 0;
}

C++实现 Stack 的特点：

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