析构和友元函数

1. 类的析构函数

析构函数的作用，用于释放该类所占用的资源（或者说释放对象）在类的对象使用完时（当类的对象超出了作用域），会自动调用析构函数；如果是在堆区实例化的对象，那么当手动释放对象时，会自动调用析构函数

析构函数的原型：
	~类名（）  //析构函数
	{

	}
例如：
~People() {//释放指针占用的空间
		delete p;

}

关键字：friend
格式：
	friend  函数返回值   函数名（参数列表）； //声明一个友元函数
例如：
	friend  void  function（）；//function函数是一个友元函数

//友元函数
class People {
public:
	//将function函数声明为People的友元
	//注意：友元函数不是类的成员函数
	friend void function(People& people);

private:
	int a=10;//普通类型变量
};

//定义一个函数去访问a，因为a是类中私有，一般是访问不到的
//所以我们需要将此函数在类中声明为友元函数
void function(People& people) {
	cout << "友元函数访问到a = " << people.a << endl;
}

int main()
{
	People people1;

	function(people1);

	return 0;
}

#include "iostream"
using namespace std;

//使用类和对象以及友元实现算数表达式的求值
//例如:
//2 + 5 + 6 - 4 + 4 - 40的和


class Jia
{
public:
	//构造函数，给属性赋值
	Jia(int m, int n)
	{
		a = m;
		b = n;
	}

	//声明友元函数
	friend void jiaFa(int a1, Jia& jia);

	void print()
	{
		cout << "temp=" << temp << endl;
	}

	//声明友元函数
	friend void update_a(Jia& jia, int a1);

	int temp;//临时存储结果，方便减法加法之间传递

private:
	int a;
	int b;
};

//加法
void jiaFa(int a1, Jia& jia)
{
	jia.b = a1;
	jia.a = jia.a + jia.b;//我们使用a来临时存储结果
	jia.temp = jia.a; //因为a是私有的在做减法时，需要将之前的结果传递给减法所以我们取出a的值给tmp，时tmp为公有方可传递给减法
}

//更新a的值
void update_a(Jia& jia, int a1)
{
	jia.a = a1;
}

class Jian
{
public:
	//声明友元函数
	friend void jianFa(int a1, int b1, Jian& jian);
	int temp;//临时存储结果，方便减法加法之间传递
};

//减法
void  jianFa(int a1, int b1, Jian& jian)
{
	jian.temp = a1 - b1;
}

int main()
{
	Jia jia(2, 5);
	jiaFa(5, jia);
	jiaFa(6, jia);
	jia.print();

	Jian jian;
	jianFa(jia.temp, 4, jian);//jian.temp=9

	update_a(jia, jian.temp);//更新a的值，使a中的临时结果，保持最新

	jiaFa(4, jia);

	jianFa(jia.temp, 40, jian);

	cout << "最终的结果：" << jian.temp << endl;
	return 0;
}

关键字：friend
格式：
	friend  class   类名；   //将类声明为友元
例如：
	friend class People; 

//友元类
class People {
public:
	//将function函数声明为People的友元
	//注意：友元函数不是类的成员函数
	friend void function(People& people);

	//将Animal声明为友元类
	friend class Animal;

private:
	int a = 10;//普通类型变量
};

class Animal {
public:
	void print(const People& people) {
		cout << "animal类中访问到a = " << people.a << endl;
	}
};

//定义一个函数去访问a，因为a是类中私有，一般是访问不到的
//所以我们需要将此函数在类中声明为友元函数
void function(People& people) {
	cout << "友元函数访问到a = " << people.a << endl;
}

int main()
{
	People people1;

	function(people1);//友元函数访问

	Animal animal;
	animal.print(people1);//友元类访问

	return 0;
}