c++模板--函数和类

目录

1.泛型编程

2.函数模板

3.类模板

1.泛型编程

        如果变写函数实现不同类型的数交换,我们在c++下会这样写.

void Swapi(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}
void Swapd(double* a, double* b)
{
	double temp = *a;
	*a = *b;
	*b = temp;
}

c语言不支持函数重载,所以实现不同类型的交换要定义不同的函数.

那么c++的实现方式是什么呢? 

void swap(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}
void swap(double& a, double& b)
{
	int temp = a;
	a = b;
	b = temp;
}

 c++引入了函数的重载和引用所以函数明可以相同,不用传指针,传引用就可以了.

使用函数重载虽然可以实现,但是也有弊端

1. 重载的函数仅仅是类型不同,代码复用率较低,只要有新的类型出现时,就需要用户增加对应的函数
2. 代码的可维护性较低,一个出错可能所有的重载都出错

那我们是否可以告诉编译器一个模子,让编译器根据不同的类型利用该模子生成不同的代码呢?

 回答时肯定的.c++引入了一个叫泛型编程的东西.那么泛型编程是什么呢?

泛型编程:编写与类型无关的通用代码,是代码复用的一种手段,模板是泛型编程的基础.

2.函数模板

        概念: 

                函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生函数的特定类型版本.

        格式:

                template<typename T1 ,typename T2,...typename tn>

                返回值类型 函数明(参数列表){}

template <typename T>
void Swap(T& a, T& b)
{
	t temp = a;
	a = b;
	b = temp;
}

注意:typename是用来定义模板参数的关键字,也可以使用class(切记:不能使用struct来代替class) 

 函数模板的原理:

        函数模板是一个蓝图,它本身并不是函数,是编译器用使用方式产生特定具体类型函数的模板.所以其实模板就是将本来因该我们做的重复事情交给了编译器做.

 在编译器编译阶段,对于函数模板的使用,编译器需要根据传入的实参类型来推演生成的对应类型的函数以提供调用.比如:当用double类型使用模板时,编译器通过对实参类型的推演,将T确定为double类型,然后产生一份专门处理double类型的代码,对于int;类型也是如此.

函数模板的实例化:

        不同类型的参数使用函数模板时,称为函数模板的实例化.参数模板的实例化分为:隐式实例化和显式实例化.

        隐式实例化:

                让编译器根据实参推演参数模板数的实际类型.

T add(const T right, const T left)
{
	return right + left;
}
int main()
{
	int a1 = 1;
	int a2 = 2;
	add(a1, a2);
	double d1 = 1.0;
	double d2 = 2.0;
	add(d1, d2);
	return 0;
}

 注意:add(a1,d1)该语句不能通过编译;因为在编译期间,当编译器看到该实例化时,需要推演其参数类型通过实参a1将T推演为int,通过d1将T推演为double类型,但是模板参数列表中只有一个T,编译器无法确定此处到底该将T确定为int或者double类型而报错.解决方案:强制类型转换和显示实例化.

显式实例化:

        在函数名后的<>中指定类型.

T add(const T right, const T left)
{
	return right + left;
}
int main()
{
	int a = 10;
	double d = 20.0;
	add<int>(a, d);
	return 0;
}

 如果类型不匹配,编译器会进行隐式类型转换,如果无法转换成功编译器会报错.

 模板参数的匹配原则:

        一个非模板函数可以和一个同名的函数模板同时存在,而且该模板还可以被实例化为这个非模板函数.

int add(int left, int right)
{
	return left + right;
}
template<class T>
T add(const T left, const T right)
{
	return left + right;
}
int main()
{
	add(1 , 2);//与非模板函数匹配,编译器不需要特化
	add<int>(1, 2);//调用编译器特化的add版本
	return 0;
}

 对于非模板函数和同名函数模板,如果其他条件相同,在调动时会优先调用非模板函数而不会从该模板产生出一个实例.如果模板可以产生一个具有跟好匹配的函数,那么将选用模板

int add(int left, int right)
{
	return left + right;
}
template<class T1, class T2>
T1 add(const T1 left, const T2 right)
{
	return left + right;
}
int main()
{
	add(1, 2);//与非函数模板类型完全匹配,不需要函数模板实例化
	add(1, 2.0);//模板函数可以生成更好的匹配版本,编译器根据实参生成更加匹配的add函数
	return 0;
}

模板函数不允许自动类型转换，但普通函数可以进行自动类型转换 

3.类模板

类模板的定义格式:

        template<class T1,class T2....class Tn>

        class 类模板名

        { 类成员定义} 

//Vector 不是具体的类,是编译器根据被实例化的类型生成具体类型的模具
template<class T>
class Vector
{
public:
	Vector(size_t capacity = 10)
		:_pDate(new T[capacity])
		,_capacity(capacity)
		,_size(0)
	{}
	~Vector();
	void Pushback(const T&d);
	void Popback();
	size_t Size(return _size);

private:
	T* _pDate;
	size_t _size;
	size_t _capacity;
};
//注意参数模板放在类外面定义时,需要加参数列表
template<class T>
Vector<T>::~Vector()
{
	if(_Date)
		delete[] _pDate;
	_pDate = nullptr;
	_size = _capacity = 0;
}

类模板的实例化:

 类模板的实例化与函数模板的实例化不同,类模板的实例化需要在类模板名字后面跟<>,然后将实例化的类型放在<>中即可,类模板名字不是真正的类,而实例化的结果才是真正的类.

// Vector类名，Vector<int>才是类型
Vector<int> s1;
Vector<double> s2;