1，结构体到类过渡
c++兼容c语言，结构用法可以继续使用，同时struct也升级成了类。
struct Stack {
//成员变量
int* a;
int top;
int capacity;
//成员函数
void Init() {
a = nullptr;
top = capacity = 0;
}
void push(int x) {
}
};
既可以用结构体的方式去访问成员变量，也可以用类的的方式去访问成员变量。
2，类的定义
（1）class 类名{主体}，主体包含成员变量，和成员函数
（2）访问限定符（三种）：public（共有），protected（保护），private（私有）
访问限定符一般作用到下一个访问限定符结束或者遇到“}”类结束
在类中，成员的默认访问限定符是私有的，所以如果不写访问限定符，类中的成员函数是无法使用的。而在结构体中，成员的默认访问限定符是共有的。
（3）类的声明和定义可以分离：
例如：
stack.h//声明部分
class Stack {
private:
int* a;//数组的地址
int top;//下一个元素的下标
int capacity;//容量
public:
void Init();
void push(int x);
int Top();
};
//定义部分
#include"stack.h"
#include <exception>
需要在类域中寻找变量，所以需要加 Stack:：
void Stack::Init() {
a = nullptr;
top = capacity = 0;
}
void Stack::push(int x) {
if (top == capacity) {
size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
a = (int*)realloc(a, sizeof(int) * newcapacity);//realloc申请空间
capacity = newcapacity;
}
a[top++] = x;
}
int Stack::Top() {
return a[top - 1];
}
注意：直接在类里面定义，会默认为内联函数，不会生成符号表
（4）类的实例化
类中的成员变量相当于声明部分，并没有分配空间，这时就需要定义开空间，也称为对象的实例化。成员变量会在对象中存储一份，但成员方法在公共代码区中。
（5）类的大小
class Date1{//类不占内存的空间
private:
int _year;//声明
int _month;
int _day;
public:
void Inti(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
};
Date d;
cout << sizeof(Date) << endl;//12
cout << sizeof(d) << endl;//12
类的大小或者说对象的大小看的是成员变量的类型和个数，且遵循内存对齐规则，所以上述对象的大小为12（3*4）
例1：
class A {//4byte
int a;
void add() {
}
};
例2：
class A1 {//内存对齐规则、8byte
int a;
char b;
void add() {
}
};
例3：class B {//1byte表示占位表示对象存在过
void add() {
}
};
class C {//1byte
};
（6）this指针：
编译器在调用成员函数是，会有一个隐藏的this指针
例如：
void Inti(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
Date d;
d.Inti(2024, 9, 9);
而编译器处理后为：
void Inti(Date* this,int year, int month, int day) {
this->_year = year;
this->_month = month;
this->_day = day;
}
Date d;
d.Inti(&d,2024, 9, 9);
但是自己写代码时，不能写成把this作为参数传递，但在类里面可以使用，比如： this->_year = year;这样的写法是可以的
总结：this在实参和形参位置不可以显示的写，但是在类里面可以显示的用，this作为形参存在栈里面，vs里面存在寄存器里面
3，构造函数
构造函数：特殊的成员函数
1,函数名与类名相同
2，无返回值
3，对象实例化时，自动调用
4，构造函数可以重载
例1：class Date {//类不占内存的空间
private:
int _year;//声明
int _month;
int _day;
public:
//无参数的构造函数
Date() {
_year = 1;
_month = 1;
_day =1;
}
//有参数的构造函数
Date(int year, int month, int day) {
_year = year;
_month = month;
_day = day;
}
*/
void Print() {
cout << _year << " " << _month << " " << _day << endl;
}
};
类中的两个构造函数两者结合一下（缺省参数）；
Date(int year=1, int month=1, int day=1) {
_year = year;
_month = month;
_day = day;
}
例2:class Stack {
private:
int* a;
int top;
int capacity;
public:
Stack() {
a = nullptr;
top = capacity = 0;
}
void push(int x) {
if (top == capacity) {
size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
int* tmp = (int*)realloc(a, sizeof(int) * newcapacity);
if (tmp == nullptr) {
perror("realloc fail");
exit(-1);
}
if (tmp == a) {
cout << capacity <<"本地扩容"<< endl;
}
else {
cout << capacity << "异地扩容" << endl;
}
a = tmp;
capacity = newcapacity;
}
a[top++] = x;
}
int Top() {
return a[top - 1];
}
void Pop() {
assert(top>0);
top--;
}
void Destroy() {
free(a);
a = nullptr;
top = capacity = 0;
}
Stack s1(1000);
for (int n = 0;n < 1000;n++) {
s1.push(n);
}在这种明确知道自己想要的空间的情况下，会不断扩容，本地扩容还好，异地扩容会非常的复杂，未了避免这种情况，我们可以写成以下这种代码：
Stack(size_t n=4) {
if (n == 0) {
a = nullptr;
top = capacity = 0;
}
else {
a = (int *)malloc(sizeof(int) * n);
if (a == nullptr) {
perror("realloc fail");
exit(-1);
}
top = 0;
capacity = n;
}
}//当你知道自己要的空间大小，这个构造函数可以减少扩容
如果你不传入参数，他会自动调用，并且空间大小初始化为4
1，不写构造函数时，编译器会自动生成，如果写了，编译器就不会提供了
2，内置类型成员不会处理（有些编译器会处理为0）(声明部分可以给缺省值)
3，对于自定义类型的成员才会处理，会去调用这个成员的构造函数，一般情况都需要我们写构造函数，决定初始化数值
4，默认构造函数，只有一个。注意：无参构造函数，全缺省构造函数，自动生成的构造函数，都默认为构造函数
总结：但是如果成员变量都是自定义类型，可以不进行初始化
4，析构函数
析构函数：
1,在类名前加 ~
2,没有参数没有返回值
3,只有一个析构函数，若没有显示定义，会自动生成一个默认的析构函数，析构函数不能重载
，内置类型成员不会处理，对于自定义类型的成员才会处理
4,在对象销毁时，自动调用析构函数
void Destroy() {
free(a);
a = nullptr;
top = capacity = 0;
}可以写成以下代码：
~Stack() {
free(a);
a = nullptr;
top = capacity = 0;
}
