C++类与对象基础探秘系列（一）

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

类的引入

类的定义

类的访问限定符及封装

访问限定符

封装

类的作用域

类的实例化

类的对象模型

如何计算类对象的大小

类对象的存储方式

结构体内存对齐规则

类成员函数的this指针

this指针的引出

this指针的特性

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

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

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

举例说明面向过程和面向对象的区别：

图书馆管理系统：

面向过程:

        关注借书、还书、查询库存等操作步骤，分别实现借书流程、还书流程、查询流程。

面向对象:

        书籍：属性有书名、作者、行为有借出、归还。

        读者：属性有姓名、借书证号，行为有借书、还书、查询个人借阅记录。

        图书馆：管理书籍集合和读者信息，提供借阅、归还、查询服务。

类的引入

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

下面是一个学生结构体示例：

//在C语言中，结构体本身不能直接包含函数定义，但你可以定义与结构体操作相关的函数。

// 定义结构体
struct Student 
{
    char name[50];
    int age;
    float score;
};

// 结构体相关的函数声明和定义
void printStudent(struct Student s) 
{
    printf("Name: %s, Age: %d, Score: %.2f\n", s.name, s.age, s.score);
}

//C++中，结构体可以像类一样定义成员函数，这些函数称为方法。

// 定义结构体，并在内部定义成员函数
struct Student 
{
    string name;
    int age;
    float score;

    // 成员函数定义
    void printInfo() 
    {
        cout << "Name: " << name << ", Age: " << age << ", Score: " << score << endl;
    }
};

类的定义

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

};  //注意后面的分号

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

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

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

2、声明放在头文件(.h)中，定义放在源文件(.cpp)中。

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

类的访问限定符及封装

访问限定符

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。

封装

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

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

例如：当你驾驶一辆汽车时，你并不需要了解发动机如何燃烧汽油产生动力、变速器如何根据车速变换挡位、刹车系统如何通过液压让车辆停止等复杂的工作原理。这些内部运作细节对普通驾驶者来说是隐藏的。你所关心的只是几个基本操作：转动钥匙启动汽车（或按下启动按钮）、踩油门加速、转动方向盘控制方向、踩刹车减速和停车。

这些简单直观的操作就是汽车制造商通过封装提供给用户的接口。换句话说，汽车制造商通过封装技术，将复杂的机械、电子系统内部的细节隐藏起来，只暴露给用户必要的操作接口（如方向盘、踏板、档杆等），使得用户无需了解车辆内部的复杂机制就能安全、便捷地驾驶汽车。这种设计不仅简化了用户的操作，也保证了系统的安全性，因为用户不太可能误操作到那些对车辆正常运行至关重要的内部组件。

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

类的作用域

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

class Person
{
public:
	//显示基本信息
	void ShowInfo();
private:
	char* _name;  //姓名
	char* _sex;   //性别
	int _age;     //年龄
};

//这里需要指定ShowInfo是属于Person这个类域
void Person::ShowInfo()
{
	cout << _name << "-" << _sex << "-" << _age << endl;
}

类的实例化

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

1、类只是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它。
就像C语言中定义了一个结构体一样，当你还未用该自定义类型创建变量时，定义结构体类型这个过程并没有分配实际的内存空间来存储它。

2、一个类可以实例化出多个对象，实例化出的对象将占用实际的物理空间来存储类成员变量。
就像你在C语言中定义了一个结构体，然后用该自定义类型创建了一个变量，那么这个变量将占用实际的物理空间来存储其成员变量。

3、类实例化出对象就像现实中使用建筑设计图建造出房子，类就是设计图。

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

类的对象模型

如何计算类对象的大小

一个类当中既可以有成员变量，又可以有成员函数，那么一个类的对象中包含了什么？类的大小又是如何计算的呢？

class Person
{
public:
	//显示基本信息
	void ShowInfo()
	{
		cout << _name << "-" << _sex << "-" << _age << endl;
	}
public:
	char* _name;  //姓名
	char* _sex;   //性别
	int _age;     //年龄
};

类对象的存储方式

C++中的类对象存储方式：

成员变量：

非静态成员变量是类实例的一部分，每一个对象都会有自己的一份副本，这些副本在对象创建时（通过构造函数）在栈上（如果对象本身在栈上创建）或堆上（如果对象是通过new操作符动态创建的）分配空间。静态成员变量则是在全局数据区分配空间，独立于任何对象实例，所有对象共享同一份静态成员变量。

成员函数：

成员函数（无论是静态还是非静态）的代码部分存储在代码段，不占用每个对象的存储空间。非静态成员函数有一个隐含的this指针，当通过对象调用时，该指针会指向调用该函数的对象实例，但这不是额外分配给每个对象的空间，而是调用时的临时行为。

我们可以通过对下面的不同对象分别获取大小来进行分析：

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

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

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

通过单目操作符sizeof来获取这三个对象的大小，结果A1的大小为4个字节，A2的大小为1个字节，A3的大小也为1个字节。

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

结构体内存对齐规则

结构体内存对齐的基本规则：

首个成员: 结构体的第一个成员总是从偏移量为0的地址开始存储。
后续成员对齐: 结构体中的其他成员变量会根据自身的大小（或类型大小）以及编译器规定的对齐要求进行对齐。对齐的基本原则是成员变量的地址应该是其大小的整数倍，且这个对齐数通常是成员大小和编译器默认对齐数的较小值。例如，在大多数x86系统上，Visual Studio默认对齐数为8字节，而GCC在许多Linux平台上默认为4字节。
结构体总大小: 结构体的总大小是所有成员变量所需的最大对齐值的整数倍。这意味着即使最后一个成员后面可能有空闲的空间（padding），以确保整个结构体的大小满足最大的对齐要求。
嵌套结构体: 如果结构体中嵌套了另一个结构体，嵌套结构体也会作为一个整体进行对齐，其起始地址需要满足嵌套结构体最大对齐数的整数倍要求。然后，外部结构体的总大小计算会继续考虑这个嵌套结构体以及之后成员的对齐需求。
显式对齐: 在某些情况下，可以通过编译器特定的指令（如C++中的#pragma pack(n)）来改变默认的对齐规则，强制结构体成员按照n字节边界对齐，这可以减少结构体的总大小，但可能会降低数据访问效率。

类成员函数的this指针

this指针的引出

先来定义一个日期类的Date：

#include <iostream>
using namespace std;
class Date
{
public:
	void Display()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	void SetDate(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.SetDate(2024, 5, 13);//设置d1的日期
	d2.SetDate(2024, 5, 14);//设置d2的日期
	d1.Display();//打印d1的日期
	d2.Display();//打印d2的日期
	return 0;
}

对于上述类，有这样的一个问题：

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

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

编译器进行编译时，看到的成员函数实际上也和我们所看到的不一样，每个成员函数的第一个形参实际上是一个隐含的this指针，该指针用于接收调用函数的对象的地址，用this指针就可以很好地访问到该对象中的成员变量：

this指针的特性

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

2、只能在“成员函数”的内部使用。

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

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

下面来段代码让我们更深了解一下this指针：

#include <iostream>
using namespace std;
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
	void Show()
	{
		cout << "Show()" << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;  
	//p->Show();       //第一句代码
	//p->PrintA();     //第二句代码
}

指针p确实是一个类的空指针，但当执行第一句代码时，程序并不会崩溃。第一句代码并没有对空指针p进行解引用，因为Show等成员函数地址并没有存到对象里面，成员函数的地址是存在公共代码段的。
当程序执行第二句代码时，会因为内存的非法访问而崩溃。执行第二句代码时，调用了成员函数PrintA，这里并不会产生什么错误（理由同上），但是PrintA函数中打印了成员变量_a，成员变量_a只有通过对this指针进行解引用才能访问到，而this指针此时接收的是nullptr，对空进行解引用必然会导致程序的崩溃。

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

通过上面学习，我们可以拿C和C++实现的Stack拿来对比一下，来看一看有什么区别。

//C语言实现

#include <stdio.h>
#include<stdlib.h>
#include<assert.h>


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)
{
	assert(!StackEmpty(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语言实现的栈总结与评价

优点:

接近底层: 直接使用指针和内存管理函数（如malloc, realloc, free）操作内存，对于想要深入了解底层机制的开发者来说是很好的实践。
灵活: 可以根据需要精确控制内存分配和释放，适用于对性能有严格要求的场景。
跨平台性: 由于使用了标准库函数，这段代码在不同平台上具有较好的兼容性。

缺点:

安全性低: 必须手动管理内存，容易出现内存泄漏或访问越界等问题。
易错性: 需要显式地检查错误条件（如内存分配失败），增加了代码的复杂度和出错的可能性。
使用不便: 相较于面向对象的语言，结构体加函数的方式在封装性和代码组织上不够直观和方便。

//C++实现

#include <stdlib.h>
#include <stdio.h>

typedef int DataType;
class Stack
{
public:
	void Init()
	{
		_array = (DataType*)malloc(sizeof(DataType) * 3);
		if (nullptr== _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);
	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语言的结构体和函数，类的成员函数调用可能会有轻微的性能开销（尤其是在早期C++版本中，现代编译器优化后差异减小）。

对比

语法风格: C++版本利用了面向对象编程的特点，代码更加面向对象和模块化，而C语言版本则是典型的结构体+函数的风格，更偏向过程化编程。
安全性与便利性: C++版本通过类的封装提高了代码的安全性和使用的便捷性，而C语言版本需要开发者自己管理内存和错误处理，增加了出错风险。
学习曲线: 对于初学者，C++的面向对象特性可能会增加学习难度，而C语言的实现方式在理解内存管理和数据结构方面更为直接。
应用领域: C语言的实现更适合对性能有特殊要求或在嵌入式系统等资源受限环境下。C++的实现则因其封装性和易用性，在通用软件开发中更为常见。

当然，随着知识的学习，后面我们会通过C++利用STL中的std::stack容器，实现更为简洁，自动处理内存管理和栈的基本操作。