C++类和对象(上)

C++教学总目录点此

类和对象分为上中下三篇

1、面向过程和面向对象初步认识

C语言是面向过程的，关注的是过程，分析出解决问题的步骤，通过函数调用逐步解决问题。
C++是面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

---

2、C++中的类

在C语言中，结构体中只能声明成员变量。
而在C++中，结构体升级成了类，不仅可以声明成员变量，还可以声明/定义成员函数。
类成员函数默认是内联函数

#include <iostream>
using namespace std;
struct stack
{
	// 成员变量
	int* a;
	int capacity;
	int top;

	// 成员函数
	void Init()
	{
		//....
	}
};

int main()
{
	struct stack s1; // 兼容C的用法
	stack s2;        // C++中升级成了类，stack就是类名
	return 0;
}

---

在C++中，我们更习惯用class来定义一个类。

class stack
{
public:
	// 成员变量
	int* a;
	int capacity;
	int top;

	// 成员函数
	void Init()
	{
		//....
	}
};

对于类中的成员函数，可以声明和定义分离，也可以写在一起：

class stack
{
public:
	// 成员变量
	int* a;
	int capacity;
	int top;

	// 成员函数
	// 声明和定义写在一起
	void Init()
	{
		a = (int*)malloc(sizeof(int) * 100);
		capacity = 100;
		top= 0;
	}
};

---

另外下面的成员变量在初始化的时候，会有命名冲突的问题。

class Date
{
public:
	void Init(int year, int month, int day)
	{
		year = year;
		month = month;
		day = day;
	}

	int year;
	int month;
	int day;
};

所以我们一般习惯在变量前面或者后面加上_，我一般是在前面加上_：

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

	int _year;
	int _month;
	int _day;
};

---

3、访问限定符

面向对象的三大特性：封装、继承、多态
那么什么是封装呢？封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

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

说明：
1、public修饰的成员可以在类外访问。
2、private和protected修饰的成员只能在类内访问（此处我们认为private和protected是一样的，后面继承部分会介绍protected的用法）。
3、访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。如果后面没有访问限定符，作用域到}结束。
4、class的默认访问权限是private，struct的默认访问权限是public(为了兼容C)

// class默认是private
class Date
{
// 共有成员，类外可以访问
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

// 私有成员，只能类内访问
private:
	int _year;
	int _month;
	int _day;
};

// struct默认是public，为了兼容C
struct stack
{
	int* a;
	int size;
	int capacity;
};

4、类对象模型

类是对对象的描述，定义一个类并没有开辟空间，需要我们手动实例化出一个对象。类是不存储成员变量的，成员变量在类中只是声明。类就相当于一个图纸，而对象就是通过图纸设计出的房屋，对象可以存储变量。

class Date
{
public:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date._year = 100; // error;
	Date d1;
	d1._year = 100;  // true
	return 0;
}

---

接下来对类的大小深入思考：计算类的大小除了要计算成员变量，需要再计算成员函数吗？另外空类是不是不占用内存呢？
下面这段代码，大家可以想想输出什么

#include <iostream>
using namespace std;

// 类中既有成员变量，又有成员函数
class A1 {
public:
    void f1() {}
private:
    char _ch;
    double _d;
};

// 类中仅有成员函数
class A2 {
public:
    void f2() {}
};

// 类中什么都没有---空类
class A3
{};
int main()
{
    cout << sizeof(A1) << endl;
    cout << sizeof(A2) << endl;
    cout << sizeof(A3) << endl;
	return 0;
}

先说结论：计算类的大小是不算成员函数的。
对于A1，有两个成员变量一个char、一个double类型，这里和C语言的结构体一样需要内存对齐，所以计算出的结果是16。(不懂内存的对齐的，可以移步下面先看内存对齐)
回过头来再看A2的大小，A2的大小是1，不计算成员函数，这1byte是为了占位，表示对象存在。
同理A3也是1byte。
C++类的成员函数实际上是存放在公共代码区的。

---

拓展：内存对齐

接下来插入内存对齐的知识点：

内存对齐规则：1、第一个成员在与结构体偏移量为0的地址处。
2、其他成员变量要对齐到某个数字（对齐数）的整数倍地址处。 对齐数=min(编译器默认的一个对齐数，该成员大小) vs默认对齐数为8
3、结构体总大小为：最大对齐数（所有变量类型的最大值和默认对齐参数之间取最小）的整数倍。
4、如果嵌套结构体，嵌套的结构体要对齐到自己最大对齐数的整数倍处，结构体的大小是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

再来看一个例子：

class A
{
private:
    int _a;
    char _ch;
};
// 计算A的大小

---

拓展：大小端字节序

什么是大端和小端？
大端（存储）模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中。
小端（存储）模式，是指数据的低位保存在内存的低地址中，而数据的高位，保存在内存的高地址中。

设计一个程序判断大端小端？

#include <iostream>
using namespace std;

int check_sys()
{
	int x = 1;
	return *((char*)&x);
}

int main()
{
	int a = 1;
	int res = check_sys();
	if (res == 1) cout << "小端" << endl;
	else cout << "大端" << endl;
	return 0;
}

---

5、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(2024, 04, 15);
	d2.Init(2024, 4, 6);
	d1.Print();
	d2.Print();
	return 0;
}

对于Date类，有一个问题。Init和Print函数中并没有对不同的对象进行区分，那么d1和d2调用的Init和Print的时候是如何区分的呢？
C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参
数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该
指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

---

this指针的特性：
1.this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
2.只能在“成员函数”的内部使用
3.this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4.this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用 户传递

1、调用成员函数时，不能显示传实参给this
2、定义成员函数时，也不能显示声明形参this
3、在成员函数内部，我们可以显示使用this。

#include <iostream>
using namespace std;

class Date
{
public:
	// 实际上是：void Init(Date* const this, int year, int month, int day);
	void Init(int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

	// 实际上是：void Print(Date* const this);
	void Print()
	{
		cout << this->_year << "-" << this->_month << "-" << this->_day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

---

接下来看有关this指针的两份代码：

#include <iostream>
using namespace std;

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void Print()
	{
		cout << "Print()" << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->Print();
	return 0;
}

这份代码运行结果是C。
分析：
1、虽然p是空指针，但是p调用成员函数不会编译报错，因为空指针不是语法错误，编译器检查不出来
2、p虽然是空指针，但是p调用成员函数也不会出现空指针访问。因为成员函数没有存在对象里面
3、这里会把p作为实参传递给隐藏的this指针

#include <iostream>
using namespace std;

// 1.下面程序编译运行结果是？ A、编译报错 B、运行崩溃 C、正常运行
class A
{
public:
	void PrintA()
	{
		cout << _a << endl;
	}
private:
	int _a;
};
int main()
{
	A* p = nullptr;
	p->PrintA();
	return 0;
}

这份代码运行结果是B
分析：这里传空指针给PrintA的this，在函数体内对空指针解引用：this->a所以程序崩溃

---

this指针存放在哪里？对象里面、栈、堆区、静态区、常量区？
this指针是形参，所以和普通参数一样存在函数调用的栈帧里面。
接下来我们看看vs下的汇编代码：首先给出程序代码

#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(2024, 4, 15);
	d2.Init(2024, 4, 6);
	d1.Print();
	d2.Print();
	return 0;
}

在vs2022下，对this指针的传递进行了优化，存放在rcx寄存器中。