【C++】类基础 + this指针

一、面向对象与面向过程

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

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

---

二、类

1. struct 结构体同时也是类

包含c语言中结构体的含义

struct Data
{
    int ID;
    char name;
};

int main()
{
    struct Data d2;
    //Data d1;  二者都可
}

---

但是从c语言中结构体不能定义函数，而C++可以将函数定义为成员

struct Data
{
	void Init(int ID = 0, char name = 0)
	{
		_ID = ID;
		_name = name;
	}

	void print()
	{
		cout << _ID << "-" << _name << endl;
	}

	int _ID;
	char _name;
};

int main()
{
	Data d1;
	d1.Init();
	d1.print();

	return 0;
}

就算这样也不会报错

这里如果char name = 0 会自动判断name为空，不会打印出来东西

而c语言中printf打印这个name的话会发生整型提升，变为0

---

2. class 类的封装

• 访问限定符

public 公有 protect 保护 private 私有

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

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

• 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

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

class Data
{
public:
	void Init(int ID = 0, char name = '0')
	{
		_ID = ID;
		_name = name;
	}

	void print()
	{
		cout << _ID << "-" << _name << endl;
	}
private:
	int _ID;
	char _name;
};

---

3. 类的定义和声明

（1）定义和声明全放在类中

类内定义的成员函数默认为inline，不论前面是否加了inline

此处内联函数会自动识别，太长或者递归的函数不会识别成内联函数

//test.h
class Data
{
public:
	void Init(int ID = 0, char name = 0)
	{
		_ID = ID;
		_name = name;
	}

	void print()
	{
		cout << _ID << "-" << _name << endl;
	}
private:
	int _ID;
	char _name;
};

---

（2）定义在.h，声明在.c

在类体外定义成员，需要使用 :: 作用域解析符，指明成员属于哪个类域。

//test.h
class Data
{
public:
    void Init(int ID = 0, char name = 0);
	void print();
private:    
	int _ID;
	char _name;
};

//test.c
#include "test.h"
void Data::Init(int ID = 0, char name = 0)
{
	_ID = ID;
	_name = name;
}

void Data::print()
{
	cout << _ID << "-" << _name << endl;
}

---

4. 类的大小

不同成员对象可以调用同一个成员函数（因为函数要重复使用，不需要重复存储同一个函数）

所以成员变量的代码分开方，而成员函数放在公共代码区（和普通的函数一样）

注意： 空类大小是1byte，不存数据，只表示对象存在

---

5. this指针

成员函数实际上隐含了一个形参

• this可以在成员函数内使用
• 形参中是Data* const this 表示this指针地址不能改变，但指针指向的内容不能改变，比如this->_year
• 成员函数实参不能写&d1，形参不能写Data* const this
• this存在栈中（因为是形参）,其实是放在寄存器ecx中，寄存器比内存，缓存访问快
• 隐含的this指针，对象是所有非静态成员函数

#include <iostream>
using namespace std;

class Date
{
public:
	void Init(int year = 0, int month = 0, int day = 0)
	{
		_year = year;
		_month = month;
		_day = day;
	}
    // void print(Date* const this)
	void print()
	{
		cout << _year << "-" << _month  << "-" << _day << endl;
        //这里的_year = this->year
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Init();
	d1.print();

	return 0;
}

---

如果是year = year 会优先访问形参（就近原则，就跟局部变量和全局变量一样，优先使用局部变量）

class Date
{
public:
	void Init(int year = 0, int month = 0, int day = 0)
	{
        //正确写法Data:year = year
        //this->year = year
        //在成员函数内部可以写this
		year = year;//这里是形参year = 形参year 不变
		_month = month;
		_day = day;
	}

	void print()
	{
		cout << _year << "-" << _month  << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

---

int main()
{
	Date d1;
	d1.Init();// &d1实参，形参是Data*this
    //d1.Init(&d1)
    //但不可以自己写 因为是隐藏的 编译器规定不可以写实参&d1、定义的时候也不能写形参this
    //this是作为一个关键字存在的
	d1.print();

	return 0;
}

---

再看一道题，关于指针的题目

编译下列代码，没有出错，但我们知道解引用空指针是错误的，但报错的时候是运行时报错。

#include <iostream>
using namespace std;

int main()
{
	int a = 10;
	int* b = nullptr;
	*b = a;
    //b = &a;同理编译不会报错

	return 0;
}

同理若出现

int main()
{
	Date* d1 = nullptr;
	d1->Init(2022,1,19);
	d1->print();

	return 0;
}

并不会报错，因为这里解引用寻找对象不在类里面，会转成call函数地址，只传参数过去了，但并没有使用

p是空指针p - > print()空指针调用成员函数不会报错，空指针不是语法错误，是运行错误

如果函数里面没有对对象的this指针进行解引用操作，运行也不会出现错误

---