类与对象的概念，内存对齐，this 指针

类可以理解为一种自定义的数据类型，可以在内存中实例化出对象，和 C 语言中的结构体很相似，但是结构体中是无法定义函数的，另外类的默认访问权限是 private

成员函数定义的方式

• 可以在类内定义，有可能被当做内联函数处理
• 类外定义的时候，在函数名前加类名和作用域限定符

类中只保存成员变量，所以类的大小也就是成员变量所占的字节数，成员函数存放在代码段 ，因为这样可以节省空间，实现代码的复用；特别注意空类也占一个字节，因为可以唯一的标识这个类所实例化出的对象，所以 C++ 给空类一个默认的成员变量

当然类所占字节数和内存对齐也有关系，各种数据按照一定的规则在空间排列

规则：第一个成员变量对齐在结构体偏移量为 0 的地址处，其它成员变量要对齐到某个数的整数倍的地址处，这个数字是编译器默认对齐数和该成员变量的较小值；

编译器的对齐数可以自定以设置，比如 #pragma pack(4)

结构体总大小为最大对齐数的整数倍(最大对齐数为最大字节的成员变量和默认对齐参数的较小值)

内存对齐的原因

• 提高 cpu 的存储和读取访问效率

• 可移植性高，某些硬件平台只能在特定的地址处取出数据，否则会出错

如何知道结构体中某个成员相对于结构体起始位置的偏移量?

一个成员的偏移量是它的实际地址与其所在段的段地址之间的距离

可以利用一个宏 offsetof

class B{
public:
	char a;//偏移量为 0
	int b;//偏移量为 4
	struct A{
		int a;
		char c;
	}bb;//偏移量为 8
};

int main(){
	cout << offsetof(B,b) << endl;
	return 0;
}

如何实现 offsetof 这个宏？

	cout << offsetof(B, b);
	cout << (size_t) & (((B*)0)->b);

两者等价，后面那条语句怎么理解？首先将 0 地址强制转换为 B* 结构体指针，再访问它的成员变量 b ,取出地址，最后将地址强制转换为 size_t 类型(unsigned int), 偏移量等于成员的地址 - 结构体的起始位置，由于结构体的起始位置是 0，所以成员地址也就相当于偏移量

this 指针

this 指针本质上其实是一个成员函数的形参，当对象调用成员函数时，编译器将对象地址作为实参传递给 this 形参，所以对象中不存储this 指针，this 指针只能在成员函数的内部使用，类型为：类类型* const

this 指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx 寄存器自动传递，不需要用户传递，所以 this 指针一般存放在寄存器里，如果成员函数中没有访问对象的时候，this 指针也可以为空

static 静态成员

静态的成员变量必须在类外定义，因为要给他分配内存，否则无法访问；类的成员变量属于整个类，为所有的对象共享，并不属于某个对象

所以可以利用共享这一特性来计算类中一共创建了多少个对象？

class A {
public:
	A() {
		++_count;
	}
	A(const A& t) {
		++_count;
	}
	static int getcount() {
		return _count;
	}
private:
	static int _count;
};

int A::_count = 0;

int main() {
	cout << A::getcount() << endl;//0
	A a1,a3;
	A a2(a1);
	cout << A::getcount() << endl;//3
	
	return 0;
}

我们可以发现在 main 函数中，类(对象也可以)可以直接调用静态成员函数，是因为静态成员函数属于类，所有对象共享，因此内部没有 this 指针，所以无法访问任何非静态成员

这也就到导致了，静态成员函数无法调用非静态成员函数，但是非静态成员函数可以调用静态成员函数

对于非静态成员函数必须使用对象来调用它.否则会破坏类的封装

友元

友元有时候提供便利，有时突破封装，所以不宜多用

举个栗子
比如我们要重载一个输出流操作符，这个时候就会遇到麻烦，因为第一个参数被 this 指针强占了，但实际 cout 输出流是需要第一个形参对象，可正常使用，这个时候我们如果重载为全局函数，但是导致无法访问到类中的私有成员，所以需要用到友元函数

友元函数可以访问类的私有成员，它是定义在类外的普通函数，不属于任何类，但是需要在类中声明，并且函数前面加一个 friend 关键字

class A {
	friend ostream& operator<<(ostream& _cout, const A& a);
public:
	A(int count = 0) {
		_count = count;
	}
private:
	int _count;
};

// 由于没有 this 指针，所以需要用户传入对象
ostream& operator<<(ostream& _cout, const A&a) {
	_cout << a._count;
	return _cout;
}

int main() {
	A a;
	cout << a << endl;

	return 0;
}

友元函数不受访问限定符的限制，不允许有 const 在函数后面修饰，因为友元函数不是成员函数，const 主要限制的是 this 指针