1. 类的定义
以下皆以日期Date类为例讲解
1.1 类定义格式
class为定义类的关键字，Date为类的名字，{}中是类的主体，注意类定义结束后分号不能省略。类体中内容称为类的成员，类中的变量称为类的属性或成员变量；类中的函数称为类的方法或者成员函数。
为了区分成员变量，一般会在变量前加一个特殊标识，一般在成员变量前后加_或者以m开头，这个并不是C++强制的。
C++中struct也可以定义类，C++兼容C语言的struct，同时将struct升级成了类，明显变化是struct中可以定义函数，日常定义类还是推荐使用class。
定义在类里面的成员函数默认是inline
cpp
class Date
{
//默认inline
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
// 这⾥只是声明，没有开空间
int _year;
int _month;
int _day;
};1.2 访问限定符
C++一种实现封装的方式，用类将对象的属性和方法结合在一块，让对象更加完善，通过访问权限将其接口提高给外部用户使用。
public修饰的成员在类外可以直接被访问，private和protected修饰的成员在类外不能直接被访问。
访问权限作用域，从该访问限定浮出现的位置到下一个访问限定符为止，如果后面没有访问限定符就作用到 } 即类结束。
一般成员变量都会被限定为private/protected，成员函数需要被别人使用的被放为public。
cpp
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;
};1.3 类域
类定义了一个新的作用域，类的所有成员都在类的作用域中。在类外定义成员需要使用::作用域操作符来指明成员属于哪个类域。
类域影响的是编译的查找规则，下面程序如果不指定类域，编译器会把Init当作全局函数，找不到_year等成员的声明/定义会报错，指定类域，就知道是成员函数，会优先在类域中查找。
cpp
//声明和定义分离 需要指定类域
void Date::Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}2. 实例化
2.1 实例化概念
用类类型在物理内存中创建出对象的过程称为类实例化出对象。
类是对象进行一种抽象化的描述，是模型一样的东西，没有分配内存，用类实例化出对象时才会分配内存。
一个类可以实例化多个对象，实例化出的对象，占用实际的物理内存，存储类成员变量。
cpp
int main()
{
// Date类实例化出对象d1和d2
Date d1;
Date d2;
d1.Init(2025, 11, 6);
d1.Print();
d2.Init(2025, 11, 11);
d2.Print();
return 0;
}2.2 对象大小
类实例化出的每个对象都有独立的数据空间，怎么计算类对象的大小呢？对象中肯定包含成员变量，那成员函数包不包含呢？函数被编译后是一段指令，对象中无法存储，成员函数如果存在一个单独的区域（代码段），对象中如果要存储，只能存储函数指针，但是细想想完全没必要，同一个函数地址是一样的，如果实例化出100个对象，每个对象都存储相同的函数指针，太浪费了！所以函数指针不需要存储，对象只存储成员变量。
C++规定类实例化对象要遵循内存对齐的规则（与C语言很类似）：
-
第一个成员对齐到和结构体变量起始位置偏移量为0的地址处（也可以说是结构体成员对齐数最大值 的整数倍的地址）。
-
其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
注：对齐数 = 编译器默认的一个对齐数 与 该成员变量大小的较小值 。
VS中默认的值为8
-
结构体总大小为最大对齐数(结构体中每个成员变量都有一个对齐数，所有对齐数中最大的)的整数倍。
-
如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍 处，结构体的整体大小就是所有最大对齐数(含嵌套结构体中成员的对齐数)的整数倍。
-
对于空类默认对齐大小为1字节，用于占位标识对象存在（C语言不存在空结构体）
3. this指针
Date类中有Init和Print两个成员函数，函数体没有关于不同对象的区别，那么d1调用成员函数时，函数是怎么区分是访问d1还是访问d2呢？这就需要用到C++的隐含的this指针了。
编译器编译后，类的成员函数默认会在形参的第一个位置，增加一个当前类类型的指针（this指针），比如Date类的Init真实原型为：
cpp
//隐藏的this指针
void Init(Date* const this, int year, int month, int day)类的成员函数想要访问成员变量，本质都是通过this指针来实现的（_this->year = year）,C++规定不能在实参和形参的位置显示写this指针（编译器会处理），但可以在函数体内显示使用this指针。
cpp
class Date
{
public:
//隐藏的this指针
// void Init(Date* const this, int year, int month, int day)
void Init(int year, int month, int day)
{
_year = year;
this->_month = month;
this->_day = day;
}
void Print()
{
cout << _year << "/" << _month << "/" << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2;
//显式调用会报错
// d1.Init(&d1, 2024, 3, 31);
d1.Init(2024, 3, 31);
d1.Print();
d2.Init(2024, 7, 5);
d2.Print();
return 0;
}4. C++实现栈与C语言实现栈对比
通过对比浅浅感受C++三大特性之一的封装
C语言实现栈参考前面文章：栈和队列
C++实现栈：
cpp
#include<iostream>
#include<assert.h>
using namespace std;
typedef int STDataType;
class stack
{
public:
void Init(int n = 4)
{
_a = (STDataType*)malloc(sizeof(STDataType) * n);
if (_a == nullptr)
{
perror("malloc fail");
return;
}
_capacity = n;
_top = 0;
}
void Push(int i)
{
if (_top == _capacity)
{
int newcapacity = _capacity * 2;
STDataType* tmp = (STDataType*)realloc(_a, sizeof(STDataType) * newcapacity);
if (tmp == nullptr)
{
perror("realloc fail");
return;
}
_a = tmp;
_capacity = newcapacity;
}
_a[_top++] = i;
}
void Pop()
{
assert(_top > 0);
--_top;
}
bool Empty()
{
return _top == 0;
}
STDataType Top()
{
assert(_top > 0);
return _a[_top - 1];
}
void Destory()
{
free(_a);
_a = nullptr;
_capacity = 0;
_top = 0;
}
private:
STDataType* _a;
size_t _capacity;
size_t _top;
};
int main()
{
stack s;
s.Init();
s.Push(1);
s.Push(2);
s.Push(3);
s.Push(4);
while (!s.Empty())
{
printf("%d\n", s.Top());
s.Pop();
}
s.Destory();
return 0;
}C语言和C++实现栈底层逻辑没有太大变化，但形态上发生了很多变化，C++实现的栈成员变量和成员函数有访问限定符的限制，不能随意通过对象修改数据，这是C++封装的一种体现；还有很多方便的语法，比如Init给的缺省参数更方便，成员函数不再需要传对象的地址（this指针帮我们传递了），使用类型不再需要typedef 用类名就很方便。