C++类与对象（中）

 1.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
 Date d1;
 Date d2;
 d1.Init(2024, 3, 31);
 d1.Print();
 d2.Init(2024, 7, 5);
 d2.Print();
 return 0;
}

运行结果如下：

转到反汇编我们看到，我们调用的都是Print函数但是为什么打印的结果却不一样？？？

那么这⾥就要用到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指针。

语法可以通过

再思考下面的问题

1 this指针->类 对象 占不占用大小?this指针不占用我们类的大小
编译器
2 this指针->地址，地址里面放的是什么?指向对象的指针 对象的首地址
3.静态的 非静态的静态的成员函数是没办法操作this?为什么?3静态函数先于对象存在 是所有对象共有的 没有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
	Date d1;
	Date d2;
	d1.Init(2024, 3, 31);
	d1.Print();
	d2.Init(2024, 7, 5);
	d2.Print();
	return 0;
}

打印结果：

this指针默认是隐含的，但是这里this指针没有发挥作用，原因在于

尽管这里声明了，但是和最先前的却不一样了，之前我们用的下划线做了形参和成员变量的区分，这里当他们变量名冲突的时候，编译器在执行：

void Init(int year, int month, int day)
{
	year = year;
	month = month;
	day = day;
}

这段代码时，不会自动使用this指针，自己赋值给自己，接下来我们添加上this指针，再看打印结果

void Init(int year, int month, int day)
{
	this->year = year;
	this->month = month;
	this->day = day;
}

代码成功打印了，所以我们在书写成员变量的时候尽量和形参名做一下区分，这样可以减少一些不必要的错误。

2.类的默认成员函数

默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我 们不写的情况下编译器会默认⽣成以下6个默认成员函数，以前四个为主：

3.构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化对象。

构造函数的特点：

1. 函数名与类名相同。

2. 无返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)

3. 对象实例化时系统会自动调用对应的构造函数。

4. 构造函数可以重载。

5. 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个无参的默认构造函数，一旦用户显式定义，编译器将不再生成。

6. 无参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函 数。但是这三个函数有且只有⼀个存在，不能同时存在。无参构造函数和全缺省构造函数虽然构成 函数重载，但是调⽤时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认⽣成那个叫 默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调用的构造就叫默认构造。

7. 我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始 化是不确定的，看编译器。对于自定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始 化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤ 初始化列表才能解决

#include<iostream>
using namespace std;
class Date
{
public:
	//全缺省构造函数
	/*Date(int year=1,int month=1,int day=1)
	{
		this->_year=year;
		this->_month = month;
		this->_day = day;
		
	}*/
	//无参构造函数
	/*Date()
	{
		this->_year = 1;
		this->_month = 1;
		this->_day = 1;
	}*/
	//带参构造函数
	Date(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;
	d1.Print();*/
	Date d2(2024, 2, 1);
	d2.Print();






	return 0;
}

// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法

// 区分这⾥是函数声明还是实例化对象

4.析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的， 函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对 象中资源的清理释放⼯作。析构函数的功能类⽐我们之前Stack实现的Destroy功能，⽽像Date没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。 析构函数的特点：

1. 析构函数名是在类名前加上字符波浪线~

2. ⽆参数⽆返回值。(这⾥跟构造类似，也不需要加void)

~Stack()
{

}

3. ⼀个类只能有⼀个析构函数。如果我们没有定义，系统会⾃动⽣成默认的析构函数。

4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数。

5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会 调⽤他的析构函数。

6. 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类 型成员⽆论什么情况都会⾃动调⽤析构函数。

7. 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如 果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源申请时，⼀定要 ⾃⼰写析构，否则会造成资源泄漏，如Stack。

8. ⼀个局部域的多个对象，C++规定后定义的先析构。

后者先析构，再析构前者

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
 Stack(int n = 4)
 {
 _a = (STDataType*)malloc(sizeof(STDataType) * n);
 if (nullptr == _a)
 {
 perror("malloc申请空间失败");
 return;
 }
 _capacity = n;
 _top = 0;
 }
 ~Stack()
 {
 cout << "~Stack()" << endl;
 free(_a);
 _a = nullptr;
 _top = _capacity = 0;
 }
private:
 STDataType* _a;
 size_t _capacity;
 size_t _top;
};
// 两个Stack实现队列

class MyQueue
{
public:
 //编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
  // 显⽰写析构，也会⾃动调⽤Stack的析构

 /*~MyQueue()
 {}*/
private:
 Stack pushst;
 Stack popst;
};
int main()
{
 Stack st;
 MyQueue mq;
 return 0;
}

像日期类没有进行资源申请，自然也不需要释放，那么就不用自己定义，而对于Stack这样的类需要资源申请，那么就需要我们自己定义析构函数