初识C++类和对象

1.类的引入

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数，同时C++引入class关键字来也能实现这一作用，C++更喜欢用class

class/struct Stack
{
	int * _array;
	size_t _capacity;
	size_t _size;

	void push(int x)
	{
		//入栈代码
	}
	void pop()
	{
		//出栈代码
	}
};

2. 面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

举个例子，如果有人和圆是两个类， 和画圆这个方法(函数)，大家认为这个对象是属于哪个类？按照一般人的思维，画圆的主体是人，当然是属于人的类，但在面向对象的思维中，画圆是圆的类。

再举个例子，如果人和门是两个类，和关门和开门两个方法(函数)，按照面向对象的思维，门是自己关/开的，人只是调用了门里关门和开门的方法，也就是给门作用力，使得门开/关的。

3.类的定义

class className
{
// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
类体中内容称为类的成员：类中的变量 称为类的属性或成员变量; 类中的函数 称为类的方法或者成员函数。

类的两种定义方式：

1. 声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

class Stack
{
	//类的属性
	int * _array;
	size_t _capacity;
	size_t _size;
	//类的方法
	void push(int x)
	{
		//入栈代码
	}
	void pop()
	{
		//出栈代码
	}
	int top()
	{
		//返回栈顶元素
	}
	int capacity()
	{
		return _capacity;
	}
	int size()
	{
		return _size;
	}
};

2. 类声明放在.h文件中，成员函数定义放在.cpp文件中，注意 !：成员函数名前需要加类名::

//.h
void Stack::push(int x)
{
	//入栈代码
}

void Stack::pop()
{
	//出栈代码
}
int Stack::top()
{
	//返回栈顶元素
}
int Stack::capacity()
{
	return _capacity;
}
int Stack::size()
{
	return _size;
}
//.c
class Stack
{
	int * _array;
	size_t _capacity;
	size_t _size;

	void push(int x);
	void pop();
	int top();
	int capacity();
	int size();
};

4.类的访问限定符及封装

4.1访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

在此有三个访问限定符给用户使用：public private
protected

例如在上文的Stack类中，栈数组_array，容量_capacity，最后元素下标 _size我并不想让外面的程序中直接对他们的数值进行修改，只允许通过调用类的方法对Stack进行调整,这时就可以用到访问限定符。

class Stack
{
public:
	void push(int x)
	{
		//入栈代码
	}
	void pop()
	{
		//出栈代码
	}
	int top()
	{
		//返回栈顶元素
	}
	int capacity()
	{
		return _capacity;
	}
	int size()
	{
		return _size;
	}
private:
	int * _array;
	size_t _capacity;
	size_t _size;


};

1. public修饰的成员在类外可以直接被访问

2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)

3. 访问权限作用域 从该访问限定符出现的位置开始直到下一个访问限定符出现时为止(以上面的程序举例，public的范围为public之后到private之前)

4. 如果后面没有访问限定符，作用域就到 } 即类结束。(以上面的程序举例,private之后没有访问限定符，就到 }结束 )

5. class的默认访问权限为private，struct为public(因为struct要兼容C)

4.2 封装

面向对象的三大特性：封装、继承、多态。
QA: 在类和对象阶段，主要是研究类的封装特性，那什么是封装呢？

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装本质上是一种管理，让用户更方便使用类。

比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

在C++语言中实现封装，可以通过类将数据以及操作数据的方法进行有机结合，通过访问权限来隐藏对象内部实现细节，控制哪些方法可以在类外部直接被使用。

5.类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::作用域操作符指明成员属于哪个类域。

//.h
void Stack::push(int x)
{
	//入栈代码
}
//.c
class Stack
{
private:
	int * _array;
	size_t _capacity;
	size_t _size;
public:
	void push(int x);
};

6.类的实例化

用类的类型创建对象的过程，称为类的实例化，类的实例化就是对象

1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。
2. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

class Stack
{
public:
	void push(int x)
	{
		//入栈代码
	}
	void pop()
	{
		//出栈代码
	}
	int top()
	{
		//返回栈顶元素
	}
	int capacity()
	{
		return _capacity;
	}
	int size()
	{
		return _size;
	}
private:
	int * _array;
	size_t _capacity;
	size_t _size;


};

int main(){
	Stack st; // 这个就叫做类的实例化
	return 0;
}

7.类对象模型

7.1计算类所占大小

类申请大小的规则与C语言的结构体一致，虽然类有成员函数，但成员函数不占用空间。

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

int main(){
	cout << sizeof(A) << endl; //  sizeof(A)= 8
}

7.2 成员函数为什么不占类的空间

假设类实例化了多个对象。因为每个对象都是独立的，所以它们的成员变量也应是相互独立的，但是，它们的成员函数都是相同的，如果每一个对象都为他们的成员函数申请空间，那么会出现大段的重复代码，相同代码保存多次，浪费空间。

类的对象只保存成员变量，成员函数存放在公共的代码段

论证，示例代码：

#include <iostream>
using namespace std;



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

int main(){
	A test1;
	A test2;
	test1.PrintA();
	test2.PrintA();
	return 0;
}

通过反汇编得到，两个对象调用的是同一个地址的函数。

7.3空类

注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

#include <iostream>
#pragma
using namespace std;

class A
{
};

int main(){
	cout << sizeof(A) << endl;
	return 0;
}

7.4 结构体内存对齐规则

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

QA:结构体为什么要进行内存对齐？

1. 对齐的数据访问可以提高缓存的命中率，从而提高程序的性能。
2. 某些处理器对于未对齐的数据访问需要额外的处理步骤，这会增加指令的执行时间。通过内存对齐可以减少这种额外的开销，提高指令的执行效率。

QA: 如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5字节即任意字节对齐？

#pragma pack(1) 
// 这段代码可以实现结构体按照任意对齐参数对齐
// 代码实现按照1字节进行对齐 ，如果想按照其他字节，将1换成其他数字即可

QA: 什么是大小端？如何测试某台机器是大端还是小端
大端就：数据的高位字节内容，保存在内存的低地址处。
小端就：数据的高位字节内容，保存在内存的高地址处。

测试大小端代码：
将数值为1的变量的地址强转为char * ，解引用出来，此时解出的值为低地址字节内容，内容为1，就是小端，内容为0，就是大端

#include <stdio.h>
int check_sys()
{
    int i = 1;
    return (*(char*)&i);
}
int main()
{
    int ret = check_sys();
    //如果是1，说明1存到了低地址字节段
    if (ret == 1)
    {
        printf("⼩端\n");
    }
    //如果是0，说明0存到了高地址字节段
    else
    {
        printf("⼤端\n");
    }
    return 0;
}

8.this指针

C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

class A
{
public:
	void PrintA()
	{
		cout << this->_a<<endl;
	}
	int _a =1;
};

8.1 this指针的特性

1. this指针的类型：类型* const，即成员函数中，不能给this指针赋值。
2. 只能在“成员函数”的内部使用。
3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针，而this指针因为是形参，一般存储在栈区。
4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。
   
   QA：this指针存在哪里？
   一般存在栈区，不在对象内部。
   QA： this指针可以为空吗？
   理论上可以，但一调用里面的成员变量，就会崩溃。

像这样就可以：

//
#include <iostream>
using namespace std;
class A
{
public:
	void Print()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

一调用里面的成员变量，就会崩溃：

#include <iostream>
using namespace std;

class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}