类与对象（上篇）

类的定义

类的引入

在 C 语言中，struct 结构体当中只能定义变量，而在 C++ 当中，结构体内不仅可以定义变量还可以定义函数。

// c 中定义结构体，只能在结构体内定义变量
struct Student {
	char name[24];
	char sex[4];
	int age;
	int score;
};
1
2
3
4
5
6
7

// c++ 中定义结构体，可以在结构体内定义变量和函数
struct Student {
	//成员函数
	void InitSu()
	{
		printf("这是一个学生类！\n");
	}
	//成员变量
	char name[24];
	char sex[4];
	int age;
	int score;

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14

定义类

class 类型 {} ；
class 是定义类的关键字，{} 内部是类的主体

两种定义类的方法

（1）声明和定义都放在类体内部

成员函数在类内定义时，编译器有可能会将其当作内联函数来进行处理

class A {
	void Show()
	{
		cout << hight << " " << wight << endl;
	}
	int hight;
	int wight;
};
1
2
3
4
5
6
7
8

（1）声明放在类内，定义放在类外

class A {
	//类内只放函数声明
	void Show();

	int hight;
	int wight;
};


void A::Show()   //类外定义函数必须限定作用域
{
	cout << hight << " " << wight << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

类的访问限定符

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

c++ 的访问限定符：
public（共有）、private（私有）、protected（受保护）

（1）public 修饰的成员在类外可以直接进行访问；
（2）protected 与 private 修饰的成员在类外不能直接被访问。

c++ 中 struct 与 class

C++ 中，struct 结构体与 class 中都可以定义成员变量与成员函数，但他们的访问限定符不一样
struct 默认访问为 public
class 默认访问为 private

类的实例化

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

class A{    //定义一个类 A
    int hight;
	int wight;
}；

A a;         // a 是	A 类的一个对象
1
2
3
4
5
6

类的大小：空类大小为 1

判断以下三个类的大小应为为多少？

class A {
	void Show()
	{
		cout << hight << " " << wight << endl;
	}

public:
	int hight;
	int wight;
};

class B {
	void show()
	{}
};

class C {

};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果：

由此可以，对比 A、B两个类可以知道类的存储仅存储类中成员变量的内容（要注意内存对齐问题）
而 C 是一个空类，为什么空类的大小会为 1 ？

假如我们设空类的大小为 0 ，那么我们用C 类定义出来的多个对象 c1,c2,c3…它们会处于同一个位置：

但是运行结果显示 ，三个对象的地址是不一样的，那么就说明了 c1,c2,c3 不是同一个位置的变量，因此我们的假设是错误的。

编译器为了防止空类定义出来的变量处于同一个位置而出错，将空类的大小设置为 1.

this 指针

C 语言回顾

在 C 语言中我们定义一个结构体，以及定义一些基本操作的函数我们会常用以下方法：

//typedef 类型重命名
typedef struct Stack {
	int capacity;
	int top;
	int* arr;
}Stack;

void StackInit(Stack* s)
{
	s->arr = (int*)malloc(sizeof(int));
	if (NULL == s->arr)
		return;
	s->capacity = s->top == 0;
}

void StackPush(Stack* s, int data)
{
	//不考虑扩容
	s->arr[s->top++] = data;
}
void StackPop(Stack* s)
{
	s->top--;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

假如我们定义一个 栈 结构的基本操作，我们可以看到在调用每一个方法的时候都会传入一个*s 的形参，调用会很繁琐，因此在 C++ 中引入了 this 指针的概念

this 指针

class Date {
public:
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

	void InitDate(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;       //定义三个不同的类对象，并对其进行初始化
	d1.InitDate(2022, 11, 13);
	d1.Print();

	Date d2;
	d2.InitDate(2022, 11, 14);
	d2.Print();

	Date d3;
	d3.InitDate(2022, 11, 15);
	d3.Print();

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

我们在定义初始化日期时并没有传入相应的对象地址，但是结果显示每个对象都可以被正确的初始化，编译器是如何做到这一步的我们来看看：

实际上在 C++ （vs编译器）下编译器给每个“非静态成员函数”增加了一个隐藏的 this 指针，让该指针指向当前的对象，在函数体中所有成员变量的操作，都是通过指针来进行访问的，这个 this 指针是系统自己来实现的并不需要用户来进行参数的传递，从而提升程序运行效率。

实际上类内部成员函数的等价表达：

void Print()
	{
		//cout << _year << "/" << _month << "/" << _day << endl;

		cout << this->_year << "/" << this->_month << "/" << this->_day << endl;
	}

	void InitDate(int year, int month, int day)
	{
		/*_year = year;
		_month = month;
		_day = day;*/


		this->_year = year;
		this->_month = month;
		this->_day = day;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

this 指针特性

（1）this 指针的类型为：类类型* const

在上一个 日期类 中：Date* const

（2）this 只能在“成员函数中使用”

（3）this 本质上是一个成员函数的形参，由对象调用成员函数时将对象地址作为实参传递给 this 形参

（4）this 是成员函数的第一个隐含的指针形参，一般情况下由编译器通过 ecx 寄存器自动来传递，不需要用户进行传递

（5）this 指针存储在栈空间上

可以采用一个引用（取别名）来获取 this 指针的地址，只要 this 指针地址位于函数栈帧之间，则说明 this 指针定义在栈上
查看 this 指针地址是否在 函数 esp ebp 之间 ---- 函数栈帧

//在成员函数中查看 this 指针的地址
Data* const& p=this;
cout<<&p<<endl;
1
2
3

（6）this 指针可以为空，但是在调用某些成员变量时会出错

因为 this 指针其实是类中成员函数的第一个隐含的形参，因此在调用成员函数时相当于将当前调用成员函数的对象地址（nullptr）作为实参传入成员函数中的 this 形参中：

但若此时在成员函数中访问成员变量则会出现一个错误提示，这是因为成员函数中对于成员变量的访问都是通过 this 指针来访问的，此时 this==nullptr 成立，因此不可以对 this->

ps：
有任何问题欢迎评论留言哦~~