C++之类和对象

类和对象

类的引入

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

typedef int DataType;
struct Stack
{
	void Init(size_t capacity)
	{
		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (nullptr == _array)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = capacity;
		_size = 0;
	}
	void Push(const DataType& data)
	{
		// 扩容
		_array[_size] = data;
		++_size;
	}
	DataType Top()
	{
		return _array[_size - 1];
	}
	void Destroy()
	{
		if (_array)
		{
			free(_array);
			_array = nullptr;
			_capacity = 0;
			_size = 0;
		}
	}
	DataType* _array;
	size_t _capacity;
	size_t _size;
};

这样子函数名字看着也更简单，代码长度也减少了。

类的定义

为什么两种写法都可以。因为C++兼容C语言，不加struct作为类也可以直接用。

//C语言的写法
struct Stack
{
	struct Stack* arr;
	size_t top;
	size_t capacity;
};

//C++的写法
struct Stack
{
	Stack* arr;
	size_t top;
	size_t capacity;

但是C++中一般不用结构体，用class来代替。

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

C++类的访问限定符及封装

下面写一个class的例子

class Stack
{
	void Init(int n=4)
	{
		arr = (int*)malloc(n * sizeof(int));
		if (arr == nullptr)
		{
			perror("malloc error");
			return;
		}
		top = 0;
		capacity = n;
	}
	int* arr;
	size_t top;
	size_t capacity;
};

int main()
{
	Stack st;
	st.Init();
}

但是这么写，我们会发现程序编不过，这就涉及到了访问限定符。
在class下面，一共有三种限定符：public（公有）,protected（保护）,private（私有）

1. public修饰的成员在类外可以直接被访问
2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)
3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
4. 如果后面没有访问限定符，作用域就到 } 即类结束。
5. class的默认访问权限为private，struct为public(因为struct要兼容C)

所以上面的代码正确改法如下

class Stack
{
public:	
	void Init(int n=4)
	{
		arr = (int*)malloc(n * sizeof(int));
		if (arr == nullptr)
		{
			perror("malloc error");
			return;
		}
		top = 0;
		capacity = n;
	}
private:	//一般成员变量放在private中，但不是一定，主要是为了保护变量不被改变
	int* arr;
	size_t top;
	size_t capacity;
};

int main()
{
	Stack st;
	st.Init();
}

类的作用域

我们写一个函数的分装

//Stack.h
#pragma once

#include<iostream>
#include<assert.h>
using namespace std;

class Stack
{
public:
	void Init(int n = 4);
private:
	int* _arr;
	int _top;
	int _capacity;
};

//Stack.c
#include"Stack.h"

void Init(int n = 4)
{
	_arr = (int*)malloc(n * sizeof(int));
	if (_arr == nullptr)
	{
		perror("malloc error");
		return;
	}
	_top = 0;
	_capacity = n;
}

但是为什么会出现这种情况呢？我明明在头文件都声明（注意，这里没有对变量开空间，所以不是定义）了啊。
我们前面说过，变量现在局部域搜索，再去全局域搜索，或者是展开的空间搜索。
而类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::作用域操作符指明成员属于哪个类域。
所以我们只需要改成这样

类的实例化

用类类型创建对象的过程，称为类的实例化。类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

类好比是造房子的设计图纸，并不占有实际物理空间。而对象好比用设计图纸造出来的房子，有实际空间。

类对象模型

类对象的存储方式

类里面一般有成员变量和成员函数，那么类里面的对象是怎么存储的呢？

//Stack.h
#pragma once

#include<iostream>
#include<assert.h>
using namespace std;

class Stack
{
public:	
	void Init(int n = 4);
	void Push(int n);
	int Top();
//private:	
	int* _arr;
	int _top;
	int _capacity;
};

//Test.c
#include"Stack.h"


int main()
{
	Stack s1;
	Stack s2;
	s1.Init();
	s2.Init();
}

我们可以看见，两个变量使用类里面的相同函数，函数的地址一样，说明类存储的函数放在公共区域
一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐（VS中默认的对齐数为8）

this指针

this指针的引出

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Display()
	{
		cout <<_year<< "-" <<_month << "-"<< _day <<endl;
	}
private:
	int _year;   // 年
	int _month;   // 月
	int _day;    // 日
};
int main()
{
	Date d1, d2;
	d1.Init(2022,1,11);
	d2.Init(2022, 1, 12);
	d1.Display();
	d2.Display();
	return 0;
}

Date类中有 Init 与 Display 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函
数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢
所以，C++就引入了我们看不见的this指针

this指针的特性

this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给
this形参。所以对象中不存储this指针

this只能在“成员函数”的内部使用，并且不能给this指针赋值。

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

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

这是个对我们理解this用法很有帮助的题目。初看两个题目没什么区别，但是在类里面的函数有着微小的区别。
看似都是传了一个空指针，但是第一个代码只是传了空指针，并没有对空指针进行什么处理，所以代码可以正常运行；而第二个代码，用空指针this指向成员变量，这就违法了。