【C++】初阶模板

前言：

        当我们要实现一个交换函数的时候，以我们现在的水平要实现一个很简单，但是我们是实现的函数仅仅可以对对指定类型进行交换，假设我们要实现一个int类型，我们就要写一个支持int类型更换的函数，只要类型一换我们就要重新写一个，而且重新写一个的底层逻辑基本是一样，这样就会造成我们的代码很冗余。而今天我们要讲的内容就很好的解决了这个问题——模板。

一、泛型编译：

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

        我们现在的水平可以使用函数重载来实现一个交换函数：
 

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}
void Swap(double& left, double& right)
{
	double temp = left;
	left = right;
	right = temp;
}
void Swap(char& left, char& right)
{
	char temp = left;
	left = right;
	right = temp;
}

        但是使用函数重载来实现的话，只要我们一增加一个类型，我们就要重新重载一个函数，而且因为逻辑基本相同，只要其中一个函数有问题，其余的都有问题，代码可维护性较低。

二、函数模板：

1.概念：

        函数模板代表了一个大家族，改模板与类型无关，在使用时被参数化，根据实参的类型生成特定函数类型版本。

2.格式：

template<typename T1,typename T2,…typename Tn>

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

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

//例如上面讲到的交换函数就可以这样实现：
template<typename T1,typename T2>
void swap(T1 a,T2 b)
{
    int tmp = a;
    a = b;
    b = tmp;
}

3.原理：

        函数模板是一个蓝图，它本身不是一个函数，是编译器使用方式生成特定具体类型函数的模具。说白了就是本来应该我们程序员来做的事情交给了编译器来完成。

        在编译器编译阶段，对于模板函数的使用，编译器是根据传入实参类型进行推导且生成对应类型函数以供调用。比如：我们用int类型使用该模板时，编译器通过对实参类型进行推导，将T1，T2确定为int类型，然后生成一个int类型的交换函数。

4.函数模板的实例化：

        用不同类型的参数使用函数模板时，称之为函数模板的实例化。模板参数实例化可以分为：隐式实例化和显示实例化。

Ⅰ.隐式实例化：让编译器根据实参类型进行推演

template<typename T1,typename T2>
void swap(T1 a,T2 b)
{
    int tmp = a;
    a = b;
    b = tmp;
}
int main()
{
    int a = 0;
    int b = 10;
    swap(a, b);

    return 0;
}

Ⅱ.显示实例化：在函数名后的<>中指定模板参数的实际类型

template<typename T1,typename T2>
void swap(T1 a,T2 b)
{
    int tmp = a;
    a = b;
    b = tmp;
}
int main()
{
    /*int a = 0;
    int b = 10;*/
    float c = 10.1;
    float d = 11.2;
    /*swap(a, b);*/
    swap<float, float>(c, d);

    return 0;
}

如果类型匹配，编译器会进行隐式类型转换。如果转换不成功编译器会报错。

5.模板参数匹配原则：

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

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); // 与非模板函数匹配，编译器不需要特化
    Add<int>(1, 2); // 调用编译器特化的Add版本
}

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

// 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
    Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
}

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

三、类模板：

1.格式：

template<class T1, class T2, ..., class Tn>
class 类模板名
{
 //类内成员定义
};

2.类模板实例化：

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

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

代码007普通

打赏 收藏 海报 链接