虚析构，友元函数和友元类，模板函数和模板类

---

前言

随着人工智能的不断发展，C++这门技术也越来越重要，本文介绍了虚析构、友元函数和友元类、模板函数和模板类的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、虚析构

1.写法：

虚析构函数只有一种写法

virtual ~类的名字（）
{

}

2.作用：

父类的指针指向子类对象的时候，delete释放父类指针，默认只会调用父类的析构，不会调用子类的析构(万一子类中有堆空间没有释放怎么办呢？？)
解决方法：在父类的析构函数前面加上virtual关键字即可
注意：只要代码中涉及到继承，你都把父类的析构函数定义成虚析构

3.虚析构的例子

#include <iostream>

using namespace std;

class Animal
{
public:
	Animal()
	{
		cout<<"Animal"<<endl;
	}
	virtual ~Animal()
	{
		cout<<"Animal析构"<<endl;
	}
};

class Dog:public Animal
{
public:
	Dog()
	{
		cout<<"Dog"<<endl;
	}
	~Dog()
	{
		cout<<"Dog析构"<<endl;
	}
};

int main()
{
	Animal *p=new Dog;
	//Dog *p=new Dog;
	delete p;
}

二、友元函数和友元类

1.引入友元

C++提供了不需要使用继承，直接就能访问其他类的所有成员的一种机制。
特点：友元是单向， 比如： A是B的友元，但是你不能B也是A的友元
友元是不能传递，也不能继承的， 比如： A是B的友元， A是C的友元，不能认为B和C也是友元关系
A是B的友元， 不能认为A的子类也是B的友元

2.友元的几种情况

第一种： 普通函数作为一个类的友元
第二种： 一个类的成员函数作为另外一个类的友元
第三种： 友元类，一个类整体作为另外一个类的友元

3.友元的优缺点

优点：提供了一种可以直接访问类的私有，保护，公有成员的一种方法(不需要通过继承，不需要通过修改权限，只需要声明成友元)
提高了程序的运行效率(减少了系统用于安全性检查的时间消耗，编译器不用再去检查你定义的权限)
缺点：破坏了类的封装性

4.普通函数作为类的友元

#include <iostream>

using namespace std;

class Card
{
public:
	Card(float _moneynum)
	{
		moneynum=_moneynum;
	}
	//声明普通函数作为Card类的友元
	friend void getCardMsg(Card &card);
private:
	float moneynum;
};

//定义一个普通函数
void getCardMsg(Card &card)
{
	cout<<"我捡到一张卡，卡里面: "<<card.moneynum<<endl;
}

int main()
{
	//定义卡的对象
	Card card(8888888);
	getCardMsg(card);
}

5.成员函数作为类的友元

#include <iostream>

using namespace std;
//前向引用声明
class Card;

class People
{
public:
	People(string _name)
	{
		name=_name;
	}
	void getCardMoney(Card &card);

private:
	string name;
};



class Card
{
public:
	Card(float _moneynum)
	{
		moneynum=_moneynum;
	}
	//声明People类的成员函数作为我自己的友元
	friend void People::getCardMoney(Card &card);
private:
	float moneynum;
};

//在类的外面实现People的成员函数
void People::getCardMoney(Card &card)
{
	cout<<"我访问了另外一个类的私有成员  "<<card.moneynum;
	//修改另外一个类的私有成员
	card.moneynum=0.0;
}



int main()
{
	//定义卡的对象
	Card card(8888888);
	
	//定义人的对象
	People p("马云");
	p.getCardMoney(card);

}

三、模板函数和模板类

1.引入模板

		int add(int a,int b)
        double add(double a,double b)               //   T  add(T a,T b)

C++把函数参数的类型抽象出来–》定义成模板

2.模板函数

定义：只要一个函数中使用了模板，这个函数就叫做模板函数

语法：template <class 模板的名字,class 模板的名字>
                     template <typename 模板的名字,typename 模板的名字>  //typename和class都是一样的作用
                     函数的定义
                     {

                     }

特点：
第一个：每个模板函数必须单独声明模板，不能共用同一个模板
第二个：模板函数跟具体版本的函数混合在一起，优先使用具体版本的函数
编译器会通过你传递的实参的类型去实例化模板函数(翻译你的模板函数为具体类型的函数)

3.模板函数的代码实例

#include <iostream>

using namespace std;

//定义一个模板函数
template <class T>  //声明一个模板，叫做T
T add(T a,T b)  //T是什么类型由实参的类型来决定
{
	cout<<"调用第一个版本的"<<endl;
	return a+b;
}

int add(int a,int b)
{
	cout<<"具体版本的add"<<endl;
	return a+b;
}

template <class T>  //声明一个模板，叫做T
T sub(T a,T b)  //T是什么类型由实参的类型来决定
{
	cout<<"调用第二个版本的"<<endl;
	return a-b;
}

template <class T1,class T2>  //声明二个模板，叫做T1和T2
T2 add(T1 a,T2 b)  //T是什么类型由实参的类型来决定
{
	cout<<"调用第三个版本的"<<endl;
	return a+b;
}

int main()
{
	int a=78;
	int b=89;
	float c=45.3;
	float d=56.3;
	cout<<add(a,b)<<endl; //编译器会将模板函数 T add(T a,T b)翻译成int add(int,int);
	cout<<add(c,d)<<endl; //编译器会将模板函数 T add(T a,T b)翻译成float add(float,float);
	cout<<add(a,c)<<endl;
}

4.模板类

定义：只要一个类中使用了模板，这个类称作模板类

5.模板类的代码实例

#include <iostream>

using namespace std;
template <class T,class T1>
class Produce //商品  模板类
{
public:
	Produce(T _price,float _cost,T1 _name)
	{
		price=_price;
		cost=_cost;
		name=_name;
	}
	void getPrice()
	{
		cout<<price<<"  "<<name<<endl;
	}
private:
	T price;
	T1 name;
	float cost;
};


int main()
{
	string str="洗发水";
	//使用模板类定义一个对象
	//Produce<float,string> pro(7.5,2.5,str);
	
	Produce<int,string> pro(7.5,2.5,str);
	pro.getPrice();
}

总结

以上就是今天要讲的内容，本文仅仅简单介绍了虚析构，友元函数和友元类，模板函数和模板类的使用，其他内容请各位大神移步本博客的其他文章，或是留言并关注博主，等待后续发布。