C++ 类和对象（1）

面向过程与面向对象的区别

C语言面向过程，关注的是过程，即需要分析出解决一个问题时有哪些步骤，如何通过函数调用进行解决问题
C++面向对象，关注的是对象，即需要将处理一件事时拆分成不同的对象，通过对象之间的交互解决

外卖系统中面向过程和面向对象之间的区别：
面向过程，我们的关注点是用户下单、骑手接单以及骑手送餐这三个过程。
面向对象，我们的关注点是客户、商家以及骑手这三个类对象之间的关系。

类的定义

在C++中，定义类的关键词有两个，分别是class和struct
两种关键字定义类的方法如下：

// 关键字class 定义类
class N{  // N为该类的名字
	// 成员变量
	int a;
	double b;
	
	// 成员方法
	void Print(int x){
		cout << x << endl;
	}
}; // 注意此处的 ";" 不能省略

// 关键字struct 定义类
struct N{  // N为该类的名字
	// 成员变量
	int a;
	double b;
	
	// 成员方法
	void Print(int x){
		cout << x << endl;
	}
}; // 注意此处的 ";" 不能省略

其中我们可以看到，类中的内容有变量和函数，在类中的内容称为类的成员：类中的变量称为属性或成员变量；类中的函数称为类的方法或者成员函数

注意： 定义在类中的成员函数默认为inline

类的两种定义方式

1、声明和定义全部放在类体中

// 声明和定义全部放在类体中
class Person{
public:
	// 打印基本信息
	void show(){
		cout << "姓名："<< _name << " 年龄：" << _age << endl;
	}
private:
	char* _name;
	int _age;
};

2、声明放在头文件(.h)，定义放在源文件(.cpp)

// 声明放在头文件 person.h
class Person{
public:
	// 打印基本信息
	void show()
private:
	char* _name;
	int _age;
};

// 定义放在源文件 person.cpp
#include "person.h"
// 打印基本信息
// 注意此处不是直接定义的 需要加上Person:: 指明该函数成员属于哪个类域
void Person::show(){
	cout << "姓名："<< _name << " 年龄：" << _age << endl;
}

访问限定符

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

说明：
1.public修饰的成员在类外可以直接被访问
2.protected和private修饰的成员在类外不能直接被访 问
3. 访问权限作用域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为止，如果后面没有访问限定符，作用域就到 } 即类结束
4. class定义成员时没有被访问限定符修饰时访问限定符默认为private，struct默认为public
5. ⼀般成员变量都会被限制为private/protected，需要给别⼈使用的成员函数会设为public

注意： 访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

C++中，struct和class的区别

C++需要兼容C语言，所以C++中的struct可以当成结构体去使用。此外，C++中的struct还可以用来定义类，和class定义类是一样的，区别是struct的成员默认访问权限是public，而class的成员默认访问权限是private

类域

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

// 指定show()这个函数成员属于Person这个类域
void Person::show(){
	cout << "姓名："<< _name << " 年龄：" << _age << endl;
}

类的实例化

⽤类类型在物理内存中创建对象的过程，称为类实例化出对象
1、类是对象的⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，用类实例化出对象时，才会分配空间

2、⼀个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

类和对象的关系，在生活中就像是房子的设计图和房子的关系，类是房子的设计图，只说明了房子应该如何建造，没有房子的实体；而对象就是根据设计图建造出来的房子，即实例化。

类的对象大小

一个类中有成员变量和成员函数，所以按道理来说，我们每个对象生成时，都包含成员变量和成员函数是没什么问题的，此时的对象大小就是成员变量所占空间大小加上成员函数所占空间大小

缺点： 每个对象中成员变量不同，所以需要有不同的空间进行存储，但是它们所调用的函数是相同的，如果每个对象都需要单独的一份内存空间存成员函数，那就浪费空间了

所以我们其实只需要一份空间存储成员函数即可

对于类的对象大小计算时，也遵守内存对齐规则
内存对齐规则：
1、第⼀个成员在与结构体偏移量为0的地址处
2、其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处
3、结构体总大小为：最⼤对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍 （vs中默认对齐数为8）
4、 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

对齐数 = 该结构体成员变量自身的大小与编译器默认的一个对齐数的较小值

注意：如果一个类中没有成员，对象的大小为1，给1字节，纯粹是为了占位标识对象存在

this指针

首先定义一个关于日期的类

#include <iostream>
using namespace std;
class Date
{
public:
	void Init(int year, int month, int day)
	{
 		_year = year;
 		month = month;
 		_day = day;
	}
	void Print()
	{
	 	cout << _year << "/" << _month << "/" << _day << endl;
    }
 
private:
	int _year; // 年
	int _month; // 月
	int _day; // 日
};
int main()
{
	Date d1, d2;//实例化两个日期类
	d1.Init(2025, 4, 27);//设置d1的日期
	d2.Init(2025, 4, 28);//设置d2的日期
	d1.Print();//打印d1的日期
	d2.Print();//打印d2的日期
	return 0;
}

问题： Date类中有Init与Print两个成员函数，函数体中没有关于不同对象的区分，那当d1调用Init和Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？

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

比如Date类的Init的真实原型其实为：

// 第一个参数为指向该对象的this指针
void Init(Date* const this, int year, int month, int day);

所以，通过将指向自己的指针传递给函数，该函数就能知道是哪个对象调用它了
类的成员函数中访问成员变量，本质都是通过this指针访问的，例如Init函数中

_year = year;

// 其实是这样的
this->_year = year;

注意： C++规定不能在实参和形参的位置显示的写this指针(编译时编译器会处理)，但是可以在函数体内显示使用this指针

this指针的特性

1、this指针的类型：类类型* const
2、this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
3、this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。
4、类的静态成员函数没有this指针

进一步理解this指针

 class A
 {
 public:
 void Print1()
 {
	 cout << "A::Print()" << endl;
 }
 void Print2()
 {
	 cout << "A::Print()" << endl;
	 cout << _a << endl;
 }
 private:
 	int _a;
 };
 int main()
 {
 	A* p = nullptr;
	// p->Print1(); // 使用1
	// p->Print2(); // 使用2
 	return 0;
 }

按道理来说，指针p是一个空指针，而使用1和使用2都通过操作符"->"间接对p进行了解引用操作，所以程序会崩溃
但是使用1的时候不会崩溃，使用2的时候才会由于内存的非法访问而崩溃

解释：

虽然指针p是一个指向类的空指针，但执行了使用1之后不会崩溃，因为使用1的Print1()函数中并没有对指针p进行解引用，因为该成员函数地址没有存到对象里面，而是存在公共代码段，既然该函数没有存到对象，所以指针p访问时就没有进行解引用了
而使用2中，如果只是访问Print2()函数也和上面一样，不会产生错误，但是函数中打印了成员变量_a，_a不存在公共代码段中，只有通过对this指针解引用才能访问到，而此时this指针接收的是nullptr，对nullptr解引用会导致错误