• 【C++】模板初阶

    1. 泛型编程

    如何实现一个通用的交换函数呢？

    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
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    使用函数重载虽然可以实现,但是有一下几个不好的地方：

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

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

    如果在C++中,也能够存在这样一个模具,通过给这个模具中填充不同材料(类型),来获得不同材料的铸件(生成具体类型的代码）,那将会节省许多头发,巧的是前人早已将树栽好,我们只需在此乘凉,

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

    image-20220121224020868

    2. 函数模板

    2.1 函数模板概念

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

    2.1 函数模板格式

    template //模板参数列表---参数类型
返回值类型 函数名(参数列表)	//函数参数列表--参数对象
{
    
}

    • 1
    • 2
    • 3
    • 4
    • 5

    template ：关键字 T也可以取x之类的,使用T:代表Type的意思

    可以定义多个模板参数,用逗号分割

    注意：typename是用来定义模板参数的关键字,也可以用class代替,但是不能用struct代替,

    交换任意两个数

    //函数模板
template
void Swap( T& left, T& right)
{
    T temp = left;
    left = right;
    right = temp;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

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

    template 等价于 template

    问题：下面两个地方的Swap函数是否相同

    //函数模板
template
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}
int main()
{
	//下面两个地方的Swap函数是否相同?
	int a = 1, b = 2;
	Swap(a, b);

	double c = 1.1, d = 2.2;
	Swap(c, d);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    不是同一个Swap函数

    ->验证,看反汇编,看函数地址

    image-20220131170008983

    调用的是不同的函数(函数地址不一样)

    注意:下列语句中,a是int类型,c是double类型, 当编译器看到实例化时:需要通过将实参a将T推导为int类型, 通过实参d将T推导为double类型, 但模板参数列表当中只有一个T,所以编译器无法确定此处将T推导为int还是double类型而报错

    此处相当于是隐式类型转化, 模板函数是不支持隐式类型转化的!

    Swap(a,c);//err

    • 1

    image-20220702153825577

    解决方法:

    1.用户自己来强制转化

    2.使用显式实例化 具体看下面

    2.3 函数模板的原理

    那么如何解决上面的问题呢？大家都知道,瓦特改良蒸汽机,人类开始了工业革命,解放了生产力,机器生产淘汰掉了很多手工产品,本质是什么,重复的工作交给了机器去完成,有人给出了论调：懒人创造世界,

    image-20220121224322737

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

    image-20220131170302708

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

    2.4 函数模板的实例化

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

      1. 隐式实例化：让编译器根据实参推演模板参数的实际类型
      template
T Add(const T& left, const T& right)
{
    return left + right;
}
int main()
{
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    //编译器根据实参推演模板参数的实际类型T分别为int和double类型
    //这种方式是隐式实例化
    Add(a1, a2);
    Add(d1, d2);
    
     /*
     Add(a1, d1);//直接这样会报错
    通过实参a1将T推演为int,通过实参d1将T推演为double类型,但模板参数列表中只有一个T,
    编译器无法确定此处到底该将T确定为int 或者 double类型而报错
    注意：在模板中,编译器一般不会进行类型转换操作,因为一旦转化出问题,编译器就需要背黑锅
    */
    
    // 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    Add(a, (int)d);//处理方式1：强制转化
    //强制转化后,d的类型不变,是生成一个临时变量传给Add函数
    return 0;
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26

    • 2.显式实例化：不让编译器推演类型,显示指定类型在函数名后的<>中指定模板参数的实际类型

      int main(void)
{
    int a = 10;
    double b = 20.0;
    // 显式实例化
    Add(a, b);
    return 0;
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8

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

    2.5 模板参数的匹配原则

    • 一个非模板函数可以和一个同名的函数模板同时存在,而且该函数模板还可以被实例化为这个非模板函数
    // 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template
T Add(T left, T right)
{
    return left + right;
}
void Test()
{
    Add(1, 2); 		//与非模板函数匹配,编译器不需要特化出一个函数
    Add(1, 2); // 调用编译器特化的Add版本
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 对于非模板函数和同名函数模板,如果其他条件都相同,在调动时会优先调用非模板函数而不会从该模板产生出一个实例,如果模板可以产生一个具有更好匹配的函数, 那么将选择模板
    // 专门处理int的加法函数
int Add(int left, int right)
{
    return left + right;
}
// 通用加法函数
template
T1 Add(T1 left, T2 right)
{
    return left + right;
}
int main() 
{
    Add(1, 2); // 与非函数模板类型完全匹配,不需要函数模板实例化
    Add(1, 2.0); // 模板函数可以生成更加匹配的版本,编译器根据实参生成更加匹配的Add函数
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    模板调用,有现成匹配函数,绝对不去实例化模板 有更匹配的,优先匹配类型最合适的

    image-20220702154745267

    3. 类模板

    我们用C语言实现栈的时候, 虽然我们可以用typedef int DataType 重命名类型,但是当我们修改存储的数据类型的时候, 比如我们想要一个栈存int类型,一个栈存char类型, 我们就需要把相同的逻辑写成两份,代码量增多 且 复杂, 而C++中有了类模板,编译器就 可以根据被实例化的类型生成一个类满足我们的需求

    3.1 类模板的定义格式

    template
class 类模板名
{
	// 类内成员定义
};

    • 1
    • 2
    • 3
    • 4
    • 5

    这里以vector为例子:

    // 动态顺序表
// 注意：Vector不是具体的类,是编译器根据被实例化的类型生成具体类的模具
template
class Vector
{
public :
    //默认构造函数
    Vector(size_t capacity = 10)
        : _pData(new T[capacity])
            , _size(0)
            , _capacity(capacity)
        {}
    
    // 使用析构函数演示：在类中声明,在类外定义,
    ~Vector();//析构函数
    
    
    void PushBack(const T& data)；
    void PopBack()；
    // ...
    size_t Size() {return _size;}
    //[]运算符重载
    T& operator[](size_t pos)
    {
        assert(pos < _size);
        return _pData[pos];
    }
private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};

// 注意：类模板中的函数如果放在类外进行定义时,需要加该函数前面加一个模板参数列表
template 
    Vector::~Vector()
    {
        if(_pData)
            delete[] _pData;
        _size = _capacity = 0;
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41

    3.2 类模板的实例化

    • 类模板实例化与函数模板实例化不同,类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>
      中即可**,类模板名字不是真正的类,而实例化的结果才是真正的类**
    // Vector类名,Vector才是类型
Vector s1;//存放int类型
Vector s2;//存放double类型
//Vector v3; //err,必须显示指定类型

    • 1
    • 2
    • 3
    • 4

    注意：类模板中,如果函数声明放在类中,在类外进行定义时,需要加模板参数列表

    //在类外面定义
//如果函数声明放在类中,在类外进行定义时,需要加模板参数列表
template <class T>
T& vector<T>:: operator[](size_t pos)
{
    assert(pos < _size);
    return _a[pos];
}

template <class T>
int vector<T>::size()
{
    return _size;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    vector是类名.模板的类型要加 -> 要加就要加template进行声明模板参数 ,因为不知道T是哪里来的

    模板不支持分离编译,也就是声明在.h文件,定义在.cpp文件 是不支持的

    Vector.h

    #pragma once
#include
#include
//防止和库里面的vecotr命名冲突->放到命名空间
namespace Mango
{
	template
class vector
{
public:
	//构造函数
	vector()
		:_a(nullptr)
		,_size(0)
		,_capacity(0)
	{}
	//析构函数
	~vector()
	{
		delete[] _a;
		_a = nullptr;
		_capacity = _size = 0;
	}
	//获取容器的元素个数
	int size();
	//尾插  
	void push_back(const T& x)
	{
		if (_size == _capacity)
		{
			//增容
			int newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			T* tmp = new T[newcapacity];
			//如果原来的空间不为空
			if (_a)
			{
				//把原来空间的内容拷贝到新空间
				for (int i = 0; i < _size; i++)
				{
					tmp[i] = _a[i];
				}
				
				//释放原来的空间
				delete[] _a;
			}
			//_a指向新空间
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_size] = x;
		_size++;
	}
	//[]运算符重载
	T& operator[](size_t pos);

private:
	T* _a;
	int _size;
	int _capacity;
};
	//在类外面定义
	//如果函数声明放在类中,在类外进行定义时,需要加模板参数列表
	template 
	T& vector:: operator[](size_t pos)
	{
		assert(pos < _size);
		return _a[pos];
	}

	template 
	int vector::size()
	{
		return _size;
	}
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75

    Test.cpp

    #include"Vector.h"
int main()
{
	/*Mango::vector v1;
	v1.push_back(1);
	v1.push_back(2);
	v1.push_back(3);
	v1.push_back(4);
	v1.push_back(5);
	for (int i = 0; i < v1.size(); i++)
	{
		v1[i] *= 2;
		cout << v1[i] << endl;
	}*/

	Mango::vector v2;
	v2.push_back(1.1);
	v2.push_back(2.1);
	v2.push_back(3.1);
	v2.push_back(4.1);
	v2.push_back(5.1);
	for (int i = 0; i < v2.size(); i++)
	{
		//v1[i] *= 2;
		cout << v2[i] << endl;
	}
	return 0;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    typename的作用

    1.声明模板参数类型名称的时候可以用class,也可以用typename

    用在模板定义里, 标明其后的模板参数是类型参数,

    template<class T>
template<typename T>

    • 1
    • 2

    2.声明类型

    模板中标明“内嵌类型名”

    image-20220222224334318

  • 相关阅读:
    感应熔炼设备市场现状及未来发展趋势分析
    【银角大王——Django课程Day1】
    HTB-Toolbox
    c语言的链接(静态链接和动态链接)以及a.out的简述
    S09-录入的数据快速分列
    连续10年霸榜第一 程序员「最常用」的编程语言是。。。。
    IB物理的费曼图怎么考？
    java毕业设计飞机订票管理系统Mybatis+系统+数据库+调试部署
    node封装mysql
    Ubuntu 虚拟化中Android Studio 不支持HAXM（CPU不支持问题）
  • 原文地址：https://blog.csdn.net/chuxinchangcun/article/details/127501554