C++模板详解--函数模板及类模板

最新推荐文章于 2023-02-28 17:37:20 发布

ing.u

最新推荐文章于 2023-02-28 17:37:20 发布

阅读量467

点赞数 5

分类专栏： C++ 文章标签： c++

本文链接：https://blog.csdn.net/qq_54717101/article/details/127600121

版权

C++ 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

泛型编程

在进入模板之前，我们先来了解一下泛型编程，如果要写一个两个数的交换函数，代码如下。

void Swap(int& a, int& b)//整型交换函数
{
   int tmp = a;
   a = b;
   b = tmp;
}

void Swap(double& a, double& b)//浮点型交换函数
{
   double tmp = a;
   a = b;
   b = tmp;
}
void Swap(char& a, char& b)//字符型交换函数
{
   char tmp = a;
   a = b;
   b = tmp;
}

注：c++的函数重载及引用传参实现

这种代码存在不足：

1、重载的多个函数仅仅只是类型不同，代码的复用率比较低，只要出现新的类型需要交换，就需要新增对应的重载函数。
2、代码的可维护性比较低，其中一个重载函数出现错误可能意味着所有的重载函数都出现了错误。

是否能 告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成相应的代码呢？

这就需要一个模版，实现不同要求。

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

函数模板

函数模板概念

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

函数模板的格式

template<typename T1,typename T2,…,typename Tn>
返回类型函数名(参数列表)
{
//函数体
}

上文写的交换函数用模板写法：

template<class T>
void Swap(T& a, T& b)
{
   T tmp = a;
   a = b;
   b = tmp;
}

这里就可以实现各种数据类型的交换
注意：typename是定义模版参数的一个关键字，可用class替代，不可struct

函数模板的原理

那么函数模板的底层原理是什么呢？其本质就是将重复的工作交给了机器去完成。

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

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

函数模板的实例化

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

1.隐式实例化

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

template<class T>
T Add(const T& a, const T& b)
{
   return a + b;
}
int main()
{
   int ret = Add(1, 1);//根据Add的实参来确定模板参数是int
   cout << ret << endl;
   return 0;
}

特别注意：使用模板时，编译器一般不会进行类型转换操作。

int a = 1;
double b = 1.1;

int ret = Add(a, b);

编译器直接报错，模板T不明确

此时，我们有两种处理方式，第一种就是我们在传参时将b强制转换为int类型，第二种就是使用下面说到的显示实例化。

2.显示实例化

在函数名后的<>中指定模板参数的实际类型

template<class T>
T Add(const T& a, const T& b)
{
   return a + b;
}
int main()
{
   int a = 1;
   double b = 1.1;
   int ret = Add<int>(a, b);
   cout << ret << endl;
   return 0;
}

注意：使用显示实例化时，如果传入的参数类型与模板参数类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功，则编译器将会报错。

函数模板的匹配原则

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

//普通函数

int Add(int a, int b)
{
   return a + b;
}

//函数模板
template<class T>
T Add(const T& a, const T& b)
{
   return a + b;
}
int main()
{
int a=1,b=2;
   int ret = Add(a, b);//调用非模板函数，编译器不需要实例化

int ret1 = Add<int>(a, b);//调用编译器实例化的Add函数
   return 0;
}

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

int Add(int a, int b)
{
   return a + b;
}
template<class T1,class T2>
T1 Add(const T1& a, const T2& b)
{
   return a + b;
}
int main()
{
   int a = 1;
   int b = 2;
   int ret = Add(a, b);//调用非模板
   double ret1 = Add<double>(1.1, b);//函数模板更加匹配，编译器会根据实参生成更加匹配的Add函数
   cout << ret << endl;
   cout << ret1 << endl;
   return 0;
}

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

类模板

类模板的定义格式

template<class T1,class T2,…,class Tn>
class 类模板名
{
//类内成员声明
};

例如：实现一个模板栈

template<class T>
class Stack
{
public:
   Stack(int capacity = 6)
       : _top(0)
       , _capacity(capacity)
       , _a(new T[_capacity])
   {}

   void Push(T val)
   {
       _a[_top] = val;
       _top++;
   }

   void Print()
   {
       for (int i = 0; i < _top; i++)
       {
           cout << _a[i] << " ";
       }
       cout << endl;
   }

   ~Stack()
   {
       delete[] _a;
       _a = nullptr;
       _top = _capacity = 0;
   }
private:
   size_t _top;
   size_t _capacity;
   T* _a;
};

注意：类模板中的成员函数若是放在类外定义时，需要加模板参数列表。

template<class T>
class Stack
{
public:
   Stack(int capacity=4)
       :_top(0)
       ,_capacity(capacity)
       ,_a(new T[_capacity])
   {}
   //类中声明，类外定义
   ~Stack();
private:
   size_t _top;
   size_t _capacity;
   T* _a;
};

template<class T>
Stack<T>::~Stack()
{
   delete[] _a;
   _a = nullptr;
   _top = _capacity = 0;
}