C++——类和对象（1）

// 定义一个类
class Stack
{
public:
    // 成员函数
    void Init(int n)
	{
		_arr = (int*)malloc(sizeof(int) * n);
		_capacity = n;
		_top = n;
	}

	void Push(int x)
	{
		// ...
	}
	// ...
private:
    // 成员变量
    // 为了区分成员变量，⼀般习惯上成员变量,会加⼀个特殊标识，如_ 或者 m开头 
    // int* m_arr;
	int* _arr;
	int _top;
	int _capacity;
}; // 分号不能省略

//代码规范
//驼峰法 StackInit  类型，函数    首字母大写开头+单词大写区分
//       initCapacity  变量      单词小写开头+单词首字母大写

//       stack_init
//		 init_capacity

// 兼容C中结构体的用法
typedef struct A
{
	// 没访问限定符，默认是public
	int _a1;
}AA;

// 升级成了类，内部可以定义函数
struct B
{
	int _b1;
	void Init()
	{}
};

//一般都用类，也有用struct的情况，比如链表
// 不再需要typedef，ListNode就可以代表类型 
struct ListNode
{
	int _val;
	// struct ListNode* next;
	ListNode* next; // 类名就是类型，不用加struct
};

class A
{
	// 访问权限作用域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为止
    // 如果后⾯没有访问限定符，作用域就到 } 即类结束
    // 一般情况就是在同一个访问限定符的放在一起
public:
	void func1()
	{}

private:
	int _a1;

public:
	int _a2;
};

// Stack.h
#include<iostream>
using namespace std;

class Stack
{
public:
	void Init(int n = 4);
private:
	int* _array;
	int _top;
	int _capacity;
};

// Stack.cpp
// 类中成员函数声明和定义分离时，定义函数时要指定类域
void Stack::Init(int n)
{
 array = (int*)malloc(sizeof(int) * n);
 if (nullptr == array)
 {
 perror("malloc申请空间失败");
 return;
 }
 capacity = n;
 top = 0;
}

#include<iostream>
using namespace std;

class Stack
{
public:
	void Init(int n = 4)
	{
		_a = (int*)malloc(sizeof(int) * n);
		_top = n;
		_capacity = n;
	}
private:
    // 这里只是声明并没有开空间
	int* _a;
	int _top;
	int _capacity;
};

int main()
{
    // Stack实例化出对象st1和st2
    // 实例化对象时，才会开辟空间
	Stack st1;
	Stack st2;

	st1.Init();
	st2.Init();

	return 0;
}

// 计算A/B/C实例化对象的大小
class A
{
public:
    // 成员函数是属于类的，而不是某个具体对象的。所有对象共享同一份成员函数的代码。
    // 代码存储在程序的代码段，而不是每个对象的数据内存中。因此，函数代码的大小不计入对象的大小。
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
	int _i;
};
class B
{
public:
	void Print()
	{
		//...
	}
};
class C
{
};

int main()
{
	cout << sizeof(A) << endl;//8
	// 开1byte是为了占位，不存储实际数据，表示对象存在过
	cout << sizeof(B) << endl;//1
	cout << sizeof(C) << endl;//1

	B b1;
	B b2;
	cout << &b1 << endl;
	cout << &b2 << endl;

	C c1;
	C c2;
	cout << &c1 << endl;
	cout << &c2 << endl;

	return 0;
}

class Date
{
public:
	// void Init(Date* const this, int year, int month, int day)
	// this指针在函数体内部可以显示使用，但是不建议
    void Init(int year, int month, int day)
	{
		this->_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	
    // this指针在形参和实参中不能显示使用(编译时编译器会处理)，但是在函数体内部可以显示使用
	// d1.Init(&d1, 2025, 10, 1);
	d1.Init(2025, 10, 1);

	// d1.Print(&d1);
	d1.Print();
	return 0;
}

class A
{
public:
	void Print()
	{
		cout << "A::print()" << endl;
	}
private:
	int _a1;
};

// 情况1：
int main()
{
    // 调用成员变量或成员函数，可以用对象或对象的指针访问
	A* ptr = nullptr;
	ptr->Print();
    // 这里的 -> 表示的是调用成员函数，而不是解引用，通过一个空指针调用成员函数Print
    // -> 只是表示调用这个成员函数，call 函数地址，而print函数(print地址编译成指令时)并没有存到p指向的对象里面(也就不存在解引用)
    // 因为函数地址在编译或链接时就已经确定了,所以就不会通过解引用去调用这个函数

	return 0;
}
// 正常运行
// ptr->Print(); 这句代码整体表示的含义就是调用A类中的Print()函数，ptr是作为参数传递给this指针                                      
// 而在Print()函数内部不存在对this指针的解引用，所以能够正常运行
// 实际上被编译器处理为
A::Print(ptr);  // 传递ptr作为this指针

// 情况2：
int main()
{
    // 调用成员变量或成员函数，可以用对象或对象的指针访问
	A* ptr = nullptr;
	(*ptr).Print(); // 这句代码表示的含义与ptr->Print();是一样的，都是调用A类中的Print()函数
    // 但是这个函数的地址并没有存在这个对象里面，所以就不会通过解引用去调用这个函数
    // ptr是作为参数传递给this指针，因为函数体内部不存在对this指针的解引用，所以能正常运行

	return 0;
}
// 正常运行

class A
{
public:
	void Print()
	{
		cout << _a1 << endl;
        // 要访问成员变量_a1，存在对this指针的解引用
		cout << "A::print()" << endl;
	}
private:
	int _a1;
};

int main()
{
	A* ptr = nullptr;
	(*ptr).Print();

	return 0;
}

// 不能正常运行