【C++模版初阶】——我与C++的不解之缘(七)

努力学习的小廉 2024-10-06 10:05:02 阅读 85

一、泛型编程

        在之前,我们想要实现一个交换两个值的函数,我们要实现好多个(int类型、double类型、char类型以及自定义类型)对于每一个类型,我们都需要实现一个交换函数:

<code>int Swap(int& x, int& y)

{

int tmp = x;

x = y;

y = tmp;

}

double Swap(double& x, double& y)

{

double tmp = x;

x = y;

y = tmp;

}

char Swap(char& x, char& y)

{

char tmp = x;

x = y;

y = tmp;

}

       实现不同类型的交换,我们可以使用函数重载,写出来好多个;

但是,这也有不足之处:

1、函数重载只是参数类型不同,代码复用率比较低,只要有新的类型,就需要用户自己添加对应的函数。

2、代码可维护性较低,一个出错可能所以的重载都出错。

        那我们可不可以只实现一个模版,让编译器根据不同的类型利用我们写的模版来自动生成相对应 的函数呢?

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

二、函数模版

        2.1、函数模版概念

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

        2.2、函数模版格式

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

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

有了模版,对于上面的交换函数我们就可以这样写:

template<typename T>

void Swap(T& x, T& y)

{

T tmp = x;

x = y;

y = tmp;

}

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

        2.3、函数模版原理

        对于函数模版,它只是一个蓝图,不是一个函数,是编译器使用方式特定具体类型函数的一个模具;

        函数模版其实就是把我们之前重复做的事情交给了编译器。

        编译器会根据参数类型生成不同的函数,这里可以通过汇编代码看一下:

#include<iostream>

template<typename T>

void Swap(T& x, T& y)

{

T tmp = x;

x = y;

y = tmp;

}

int main()

{

int a = 1, b = 2;

Swap(a, b);

double c = 1.1, d = 2.2;

Swap(c, d);

return 0;

}

        这里可以看到,编译器根据不同的参数,生成了不同的函数Swap<int>、Swap<double>

        2.4、函数模版实例化

        在使用不同类型的参数使用函数模版时,称为函数模版的实例化。

模版的实例化又分为:隐式实例化和显式实例化。

2.4.1、隐式实例化

        所谓隐式实例化,就是让编译器根据实参推演模版参数的实际类型

但是这样也会遇到一些问题,就比如如下函数:

<code>template<typename T>

T Add(const T& x, const T& y)

{

return x + y;

}

int main()

{

int a = Add(1, 2); //两个int类型

int b = Add(1.1, 2.2); //两个double类型

int c = Add(1, 2.2); // int double 类型

return 0;

}

    

如上述情况,编译器会报错:没有与参数列表匹配的函数模版。

        在编译期间,当编译器看到该实例化时,需要推演其实参类型通过实参1 将T推演为int,通过实参 2.2  将T推演为double类型,但模板参数列表中只有一个T编译器无法确定此处到底该将T确定为int 或者 double类型而报错。

解决这个问题有两种方法,        

        1、强制类型转换。

        2、模版函数显示实例化

2.4.2、显示实例化

        显示实例化:在函数名后面的<>中指定模版参数的实际类型。

<code>int main(void)

{

int a = 10;

double b = 20.0;

// 显式实例化

Add<int>(a, b);

return 0;

}

        2.5、模版参数的匹配原则

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

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

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

三、类模版

        3.1、类模版的定义格式

        

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

class 类模板名

{

// 类内成员定义

};

        在之前,我们实现的数据结构,线性表、栈和队列等中,我们只能存储一种类型的数据。如果我们想要存储其他类型,就要重新实现一个数据结构;有了模版,我们只需要写出来一个模具,让编译器自动生成存储不同类型的类。

这里简单实现一下。

//类模版

template<typename T>

class Stack

{

public:

Stack(int capacity = 4)

{

_arr = new T[capacity];

_top = 0;

_capacity = capacity;

}

~Stack()

{

delete[] _arr;

_arr = nullptr;

_top = _capacity = 0;

}

void Push(T& x);

void Pop();

bool Empty()

{

return _top == 0;

}

private:

T* _arr;

size_t _top;

size_t _capacity;

};

template<typename T>

void Stack<T>::Push(T& x)

{

if (_top >= _capacity)

{

T* tmp = (T*)realloc(_arr, sizeof(T) * 2 * _capacity);

if (tmp == nullptr)

{

exit(1);

}

_arr = tmp;

_capacity *= 2;

}

_arr[_top++] = x;

}

template<typename T>

void Stack<T>::Pop()

{

_top--;

}

        3.2、类模版的实例化

        类模版实例化和函数模版的实例化不同,类模版实例化需要在类模版名字后面跟<>,然后将实例化的类型放在<>中即可。

注意:类模版名字不是真正的类,实例化的结果才是真正的类。

//Stack类名,Stack<int>/Stack<double>才是类型

Stack<int> s1;

Stack<double> s2;

扩展:

        类模版在声明和定义分离时(类里面声明,类外面定义)与普通的类不同:

类里面声明:

类外面定义:

模版初阶大致内容就这些,后面还会深入学习模版的内容。

感谢各位大佬支持并指出问题,

                        如果本篇内容对你有帮助,可以一键三连支持以下,感谢支持!!!



声明

本文内容仅代表作者观点,或转载于其他网站,本站不以此文作为商业用途
如有涉及侵权,请联系本站进行删除
转载本站原创文章,请注明来源及作者。