【C++类和对象（上）】—— 我与C++的不解之缘（三）

前言：

通过了C++入门基础的学习，对C++有了一定的了解，现在来学习C++中的类和对象

一、类的定义

        1.1、类的定义格式

class 为定义类的关键字，Stack为类的名字，{}中为类的主体（注意类定义结束后的分好不能省略），类体中内容称为类的成员：类中的变量称为类的属性(或者 类的成员变量)；类中的函数称为类的方法(或者 类的成员函数)。 为了区分成员变量，（习惯上会加上一个特殊标识，前面或者后面加上_或m(这只是惯例，C++ 没有要求)）。 C++中struct也可以定义类，C++兼容C语言struct的用法，而且把struct 升级成了类（可以定义成员函数），一般还是使用class 来定义类。 定义在类里面的成员函数默认为 inline。

这样就定义了一个域Data，Init 和 Print 是成员函数；_year、_month 和 _day是成员变量。

class Data
{
public:
	//成员函数
	void Init(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	//成员变量
	int _year;
	int _month;
	int _day;
};

        1.2、访问限定符

C++一种实现封装的方式，用类将对象的属性和方法结合在一起，让对象更加完善，通过访问权限选择性的将接口提供给外部的用户使用 public 修饰的成员在类外可以直接被访问，protected 和privata修饰的成员在类外不能直接被访问，（在继承中才能体现出protected 和privata的区别）。 访问权限作用域从该访问限定符出现的位置开始，直到下一个访问限定符出现为止；如果后面没有访问限定符，作用域就到 } 为止。 class定义成员没有被访问限定符修饰时默认为private，struct默认为public。 ⼀般成员变量都会被限制为private/protected，需要给别⼈使⽤的成员函数会放为public。

访问权限有以下三种：

以上面定义的域Data为例，privata 修饰的成员是私有的，不能直接被访问。

而public修饰的成员可以被直接访问。

        1.3、类域

类定义了应该新的域，类的所有成员都在类的作用域中，在类体外定义成员时，需要使用  ::  作用域操作符来指明成员属于那个类域 类域影响的是编译的查找规则，下面程序如果不指定类域Stack，那编译就把Init当成了全局函数，那么编译时，就找不到array等成员的声明和定义，就会报错；指定类域Stack，就知道Init是成员函数，当前域找不到array等成员，就会到类域中去查找。

这里，类里的成员函数如果声明和定义分离，就需要指定类域，

class Stack
{
public:
	// 成员函数
	void Init(int n = 4);
private:
	// 成员变量
	int* array;
	size_t capacity;
	size_t top;
};
// 声明和定义分离，需要指定类域
void Stack::Init(int n)
{
	array = (int*)malloc(sizeof(int) * n);
	if (nullptr == array)
	{
		perror("malloc申请空间失败");
		return;
	}
	capacity = n;
	top = 0;
}
int main()
{
	Stack st;
	st.Init();
	return 0;
}

二、类的实例化

        2.1、实例化出对象

用类这一类型在物理内存中创建对象的过程，称为类实例化出对象 类是对象进行一种抽象描述，是一个模型一样的东西，限定了类有哪些成员，这些成员只是声明，没有分配空间，有用类实例化出对象时，才会分配空间 一个类可以实例化出多个对象，而实例化出的对象，占用实际的物理空间，存储类成员变量。

        这里类就像C语言实现链表时，创建的链表节点的结构体一样；只是限定了有哪些成员，没有实际开辟空间，只有在使用的时候才开辟空间创建变量。

class Data
{
public:
	//成员函数
	void Init(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	//成员变量
    //只声明，没有开辟空间
	int _year;
	int _month;
	int _day;
};
int main()
{
    //Data实例化出对象 d1
	Data d1;
	d1.Init();
	d1.Print();
    //Data实例化出对象 d2
	Data d2;
	d2.Init(2024, 8, 7);
	d2.Print();

	return 0;
}

        2.2、对象的大小       

        这里实例化出的每一个对象都有独立的空间，那么这些对象的大小该入额计算呢？

类中存在成员变量：

        这里，大小只计算成员变量的大小，成员函数不计算在内，（计算成员变量的大小与C语言中计算结构体一样都遵循内存对齐规则）

计算一下，上面类Data实例化对象d1的大小：

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

	cout << sizeof(d1) << endl;
	return 0;
}

        大小为12（单位字节）

类中不存在成员变量：

        这里可能有点疑惑，上面不是说只计算成员变量的大小吗？那不存在成员变量，大小又是多少呢？

        如果不存在成员变量，那对象的大小为1，（这里为什么没有成员变量，还要给一个字节空间呢？）这里如果空间大小为0，那怎么表示这个对象是否存在呢?（这里的一个字节，纯粹是占位标识对象存在）。

class H
{
public:

};

int main()
{
	H h;
	cout << sizeof(h) << endl;
	return 0;
}

三、this指针

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调⽤Init和 Print函数时，该函数是如何知道应该访问的是d1对象还是d2对象呢？那么这⾥就要看到C++给了 ⼀个隐含的this指针解决这⾥的问题 编译器编译后，类的成员函数默认都会在形参第⼀个位置，增加⼀个当前类类型的指针，叫做this 指针。⽐如Date类的Init的真实原型为， void Init(Date* const this, int year, int month, int day) 类的成员函数中访问成员变量，本质都是通过this指针访问的，如Init函数中给_year赋值， this- >_year = year; C++规定不能在实参和形参的位置显⽰的写this指针(编译时编译器会处理)，但是可以在函数体内显 ⽰使⽤this指针。

 this指针的特性：

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

class Date
{
public:
	// void Init(Date* const this, int year, int month, int day)
	void Init(int year, int month, int day)
	{
		// this = nullptr;
		// this->_year = year;
		_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Print()
{
	cout << _year << "/" << _month << "/" << _day << endl;
}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// Date类实例化出对象d1和d2
	Date d1;
	Date d2;
	// d1.Init(&d1, 2024, 3, 31);
	d1.Init(2024, 3, 31);
	d1.Print();
	d2.Init(2024, 7, 5);
	d2.Print();
	return 0;
}