类和对象（上）

类和对象（上）

类的定义

类定义格式

• class为定义类的关键字，类中的变量称为类的属性或成员变量; 类中的函数称为类的⽅法或者成员函数
• C++中struct也可以定义类，C++兼容C中struct的⽤法，同时struct升级成了类，明显的变化是struct中可以定义函数，⼀般情况下我们还是推荐⽤class定义类

也就是在C++中的struct中，我们不用再typedef了，struct后面的就是类名，可以直接使用

// 不再需要typedef，ListNodeCPP就可以代表类型
struct ListNodeCPP
{
	void Init(int x)
	{
		next = nullptr;
		val = x;
	}
	ListNodeCPP* next;
	int val;
};

• 定义在类⾯的成员函数默认为inline，在类内直接定义就是内联，声明和定义分开（类内声明，类外定义）就不是内联

访问限定符

public、private、protected

• C++⼀种实现封装的⽅式，⽤类将对象的属性与⽅法结合在⼀块，让对象更加完善，通过访问权限选择性的将其接⼝提供给外部的⽤⼾使⽤。

• 一个访问限定符限制的是从该访问限定符开始，到下一个访问限定符结束之间，如果后⾯没有访问限定符，作⽤域就到 }即类结束

• class默认访问属性是私有private，struct默认访问属性是public

• 一般情况下，成员变量会被设置为私有和保护，具体要看你想不想给别人访问

• public修饰的成员在类外可以直接被访问；protected和private修饰的成员在类外不能直接被访问，protected和private是⼀样的，以后继承章节才能体现出他们的区别

总结一下：C++中，类名就代表类型，可以直接用，不用typedef，但是之前那一套也可以继续玩，因为C++兼容C

C++中，用花括号{}括起来的就形成了一个新的域

类域

类域影响的是编译的查找规则。

定义一个类，就形成了一个新的域，只影响名字隔离，不影响生命周期

类中定义的变量只能是变量的声明，因为没有开空间，只有实例化才会开空间，类只是一张图纸，只有实例化对象才会开辟空间

struct Date
{
public:
	void Init(int year, int month, int day);
private:
	int _year;
	int _month;
	int _day;
};

这里的_year, _month, _day都是声明，定义必须要开空间，如果你是定义，那你就可以用Date:: _year去访问，但很明显，这里不可以，因为它是声明

实例化

类和对象是一对多的关系，一个类可以实例化多个对象

实例化概念

就是用类定义一个对象

对象大小

我们之前在介绍结构体的时候，就提到了结构体对齐的概念，那么在类中是否也有这样的概念呢？

当然有，在搞清楚对象大小之前，我们首先要分析清楚类中有哪些东西，首先成员变量肯定是需要空间的，那么，成员函数呢？

一个类实例化出的不同对象的成员函数肯定是不一样的，那不同的对象所指向的成员函数是否不一样呢？

答案是一样的，虽然两个成员的成员变量存储各自的数据，但是他们的成员函数指针是一样的，所以如果我们把成员函数存储在对象中，就会存在浪费的现象，我们的成员函数存在公共区域。

内存对齐规则

和C语言类似

• 第一个成员在与结构体偏移量为0的地址处。
• 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
• 注意:对齐数=编译器默认的一个对齐数与该成员大小的较小值。
• VS中默认的对齐数为8
• 结构体总大小为:最大对齐数(所有变量类型最大者与默认对齐参数取最小)的整数倍。如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。

注意：成员函数不存对象里面。

CPU是从固定整数位置读取固定长度，内存对齐是为了方便CPU

那么没有成员变量的类是多大呢？

class A
{

};

int main()
{
    A a;
    A b;
}

如果不开空间，那你这个a和b对象是怎么实例化出来的？

所以，没有成员变量的类的大小是1，这里的1字节纯粹是为了占位，表示对象存在。以后会介绍仿函数，这个函数的类全是这种空类

this指针

再来解决一个问题：

class Date
{
public:
	void Init(int y, int m, int d)
	{
		_year = y;
		_month = m;
		_date = d;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _date << endl;
	}

private:
	int _year;
	int _month;
	int _date;
};

int main()
{
	Date d1;
	Date d2;

	d1.Init(2024, 3, 31);
	d1.Print();

	d2.Init(2024, 7, 5);
	d2.Print();

	return 0;
}

函数编译完了就是一段指令，函数指针可以认为是第一句指令的地址。

可以看到，d1和d2两个函数call的地址都是一样的，说明是同一个函数，那把这两个函数在每一个对象里面都存一个，就很没必要，所以这个函数的指针会存在一个公共的地方，以后我们会介绍，也就是说，d1和d2有各自独立的成员变量，但是二者的函数指针是一样的。

既然如此，d1和d2的成员函数都是一样的，是怎么实现打印出的内容不一样的？凭什么？

这里就隐含了this指针来解决这个问题，所以这里的Print()函数应该是Print(Date* const this),Init()函数应该是Init(Date* const this, int y, int m, int d),他们都有一个隐含的this指针

然后我们调用这个成员函数的时候，它会偷偷传一个当前对象的地址过去，也就是：

d1.Init(&d1, 2024, 3, 31);
d2.Init(&d2, 2024, 7, 5);

现在我就知道谁是谁了

成员函数本质上也是通过this访问的

	void Init(int y, int m, int d)
	{
		this->_year = y;
		this->_month = m;
		this->_date = d;
	}

	void Print()
	{
		cout << this->_year << "/" << this->_month << "/" << this->_date << endl;
	}

C++规定在实参和形参的位置不能显式的写this,因为编译时编译器会自己处理，但是在函数体内可以显式使用。

注意，this是不能被修改的，但是this指向的内容是可以修改的，因为这里的const是在Date*之后的

	void Print()
	{
		this++;//这是不可以的
		this->_year = 100;//这是可以的
		cout << this->_year << "/" << this->_month << "/" << this->_date << endl;
	}

this指针存储在内存的栈区，因为它是一个形参，但是不完全对，因为this指针频繁使用，VS会把它放在寄存器里，所以说this指针存储在寄存器里也是对的，要具体情况具体分析,因为寄存器是编译器特定化的东西，不同编译器实现这个可能有所区别。