类和对象

 两个类域
class Stack
{
public:
	void Push(int x)
	{}
};

class Queue
{
public:
	void Push(int x)
	{}
};

class Stack
{
public:
	// 在类里面定义
	// 在类里面定义的函数默认是inline
	void Init()
	{
		_a = nullptr;
		_top = 0;
		_capacity = 0;
	}

	// 在类里面声明， 在.cpp里面定义
	void Push(int x);
	void Pop();
	// 总结一下：实际中，一般情况下，短小函数可以直接在类里面定义，长一点函数声明和定义分离
private:
	// 声明
	int* _a;
	int _top;
	int _capacity;
};

总结：实际中，一般情况下，短小函数可以直接在类里面定义，长一点函数声明和定义分离

————————————————————————————手动分割符————————

类中的成员变量也是声明

private:
	// 声明
	int* _a;
	int _top;
	int _capacity;

类中的成员变量的定义在哪？：在创建对象的时候，开辟了成员变量的空间，所以属于定义（此时st1内部的值未初始化都是随机值）

int main()
{
	Stack st1;
}

————————————————————————————手动分割符————————

只保存成员变量，成员函数存放在公共的代码段（静态变量区）

类对象大小不考虑成员函数，因为成员函数存放在公共的代码段

所以正常按内存对齐计算就行

举个常规例子：

 过程：_a 自身大小4字节，默认对齐数是8, 4 和 8取较小值4作为对齐数，则需要从对齐到4的整数倍的空间开始，占内存的0~3个字节，_ch 自身大小1字节，1 和 8取较小值1作为对齐数，则需要从对齐到1的整数倍的空间开始，占内存的第4个字节，一共5个字节，内存对齐：最大对齐数是三个对齐数1 4中的4，则结构体的总大小是4的倍数，则让 5 再浪费三字节空间到了偏移量 8 的位置，总共8字节空间

例子2：没有成员变量的类对象多大？空类多大？——都是1字节

因为：没有成员变量的类对象，编译会给他们分配1byte占位，表示对象存在过

class Date
{
public:
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	/*void Print(Date* const this)
	{
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	}*/
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	/*void Init(Date* const this, int year, int month, int day)
	{
	this->_year = year;
	this->_month = month;
	this->_day = day;
	}*/

private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1;
	Date d2;

	d1.Init(2022, 5, 11);
	d2.Init(2022, 5, 12);
	//d1.Init(&d1, 2022, 5, 15);
	//d2.Init(&d2, 2022, 5, 20);

	d1.Print();
	d2.Print();
	//d1.Print(&d1);
	//d2.Print(&d2);

	return 0;
}

调用时this指针是隐含的，d1调用Print函数时，传参传过去就是d1的地址，Print函数接收时利用隐含的this指针接收了d1的地址，内部的成员变量前面默认都是this指向的，比如_year相当于      this->_year，

当然①类里面可以显示的把访问写出来，即：可以自己写上 this-> 。（不写编译器也会自己加上，所以我们一般都不加this->）

②也可以在类中打印this，即：cout<< this <

③但是不可以在实参和形参位置显示的写出this，即： void Print() 不允许写成 void Print(Date* this) ，不允许在形参加上this

④//this =nullptr; 是错误的： this指针本身不能修改，因为他是const修饰的
// this指向对象可以被修改 this->_year=year;
 

    d1.Print();    //d1.Print(&d1);
	d2.Print();    //d2.Print(&d2);

    void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
Print加上this指针后就是如下：
    //void Print(Date* this)
	//{
	//	cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	//}

Date d1;
d1.Init(2022, 5, 11);    //d1.Init(&d1, 2022, 5, 15);
类里面成员函数：
void Init(int year, int month, int day)
//void Init(Date* const this, int year, int month, int day)

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

【1】下面程序编译运行结果是？  A、编译报错  B、运行崩溃  C、正常运行

class A
{
public:
	void Show()
	{
		cout << this << endl;    //打印空指针也没错
		cout << "Show()" << endl;
	}
//private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->Show();
    //如果是 p->_a; 就有错
}

————————————————————————————手动分割符————————

在编译成中间语言的时候就没通过,也就是语法有错误,简单的说,

就是"你说的话,人家完全听不懂,没法帮你编译"所以是编译错误,

这个是原则性的错误.这个图就是语法错误！！

而编译通过了,但是运行时错误,说明编程人员对代码的思想有错误,

简单的说就是"你说的话,人家听得懂,但是不明白你什么意识",语无伦次的

让对方不知道你想做什么,就运行时错误了.

————————————————————————————手动分割符————————

选C、正常运行。首先一定不能选A，因为野指针问题都是运行时崩溃，编译器并不能自己检查出来

尽管p是空指针，但空指针是实参，把空指针实参传给形参是没错的，并且p-> Show()  ,Show()成员函数放在公共的代码区，编译时去公共的代码区找到函数Show()，转换成 “call（函数的地址）”，就是普通的函数调用，cal1  A: :Show ( 0BA14D8h)，并没有解引用空指针

 p->_a; 类里面只存成员变量，访问了空指针的成员变量，解引用空指针会报错，所以错误，但是不会崩溃，编译器优化会忽略这个代码，因为什么事都没做。如果是访问修改这个代码就会报错： p->_a=0;

【2】下面程序编译运行结果是？  A、编译报错  B、运行崩溃  C、正常运行

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};

int main()
{
	A* p = nullptr;
	p->PrintA();

}

 选B、运行崩溃   ，访问了空指针的成员变量，会解引用空指针，运行崩溃，但语法还是对的，所以不是A是B。