模板（C++）

已于 2024-04-07 16:54:03 修改
阅读量161 收藏
点赞数
分类专栏： C++ 文章标签： c++ 模板
于 2023-08-19 15:59:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kpl_20/article/details/132132789
版权

模板

一、泛型编程

泛型编程： 编写通用的、具有普适性的代码，以处理各种不同类型的数据。编写与类型无关的通用代码，是代码复用的一种手段。模板就是泛型编程的基础

在没有学习模板之前，通过之前学习的知识，我们知道了函数重载。可以通过函数重载实现不同类型的相同功能的同名函数。函数重载

函数重载的缺点：

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

eg：函数重载

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. 函数模板

①概念

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

函数模板的语法：
template<typename T1, typename T2,...., typename Tn>
返回值类型 函数名(参数列表) {}

注： typename是用来定义模板参数的关键字，typename也可以换成class。但是struct不能替换typename，在类名中struct和class可以替换使用，这里不行

eg：

template<typename T>
void Swap(T& left, T& right)
{
	T temp = left;
	left = right;
	right = temp;
}

int main()
{
	int a1 = 10;
	int b1 = 1;
	Swap(a1, b1);
	cout << "a1=" << a1 << " b1=" << b1 << endl;

	double a2 = 1.1;
	double b2 = 10.1;
	Swap(a2, b2);
	cout << "a2=" << a2 << " b2=" << b2 << endl;
	
	//...
	return 0;
}

//运行结果：
// a1=1 b1=10
// a2=10.1 b2=1.1

②原理

函数模板是一个蓝图，他本身不是函数，是编译器使用方式产生特定具体类型函数的模具。所以模板就是将本来我们做的重复的事交给编译器。

编译器在编译阶段，对于使用的函数模板，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。
图解：
模板

③函数模板实列化

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

  1. 隐式实例化

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

template<typename T>
//这const要加，因为实参被强制类型转化
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	int a1 = 10, a2 = 20;
	double d1 = 10.1, d2 = 20.2;
	Add(a1, a2);
	Add(d1, d2);

	//因为模板参数列表就一个T,编译器无法确定T是int类型还是double类型
	//在模板中，编译器不会进行类型转换操作，因为转换出现问题，就是编译器的原因
	//Add(a1, d1);   //err

	//两种处理方式：1.用户自己强转 2.使用显示实列化(后面讲)
	Add(a1, (int)d1);       //强转d1生成临时变量，不影响d1本身
	Add((double)a1, d1);

	return 0;
}
  1. 显示实例化： 在函数名后的<>中指定模板参数的实际类型。

eg1：

template<typename T>
T Add(const T& left, const T& right)
{
	return left + right;
}

int main()
{
	int a = 10;
	double b = 20.1;

	//显示实列化
	Add<int>(a, b);  // b 在这里就会隐式类型转换
	return 0;
}

类型不匹配编译器会尝试进行隐式类型转换，无法转换成功编译器会报错。

eg2：有写函数无法自动推，只能显示实列化。

template<class T>
T* Alloc(int n)
{
	return new T[n];
}

int main()
{
	//只能显示实列化
	double* p1 = Alloc<double>(10);
	//double* p1 = Alloc(10);   //err
	return 0;
}

④模板参数匹配原则

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

eg1：

int Add(int left, int right)
{
	return left + right;
}

template<class T>
T Add(T left, T right)
{
	return left + right;
}

int main()
{
	Add(1, 2);        //与非模板函数匹配，编译器不需要特化
	Add<int>(1, 2);   //调用编译器特化的Add版本
	return 0;
}
  1. 对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板。

eg2：

int Add(int left, int right)
{
	return left + right;
}

template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
	return left + right;
}

int main()
{
	Add(1, 2);        //与非模板函数类型完全匹配，不需要函数模板实列化
	Add(1, 2.0);      //模板函数可以生成更加匹配的版本
	return 0;
}
  1. 在 C++ 中，模板函数不会自动进行类型转换，而普通函数会。
    eg3：
template <typename T>
void templateFunction(T value) {
    std::cout << "Template function: " << value << std::endl;
}
void normalFunction(int value) {
    std::cout << "Normal function: " << value << std::endl;
}

int main() {
    int intValue = 10;
    double doubleValue = 3.14;

    templateFunction(intValue);  // 不会进行类型转换，输出：Template function: 10
    templateFunction(doubleValue);  // 不会进行类型转换，输出：Template function: 3.14

    normalFunction(intValue);  // 进行了隐式类型转换，输出：Normal function: 10
    normalFunction(doubleValue);  // 进行了隐式类型转换，输出：Normal function: 3

    return 0;
}

在上述代码中，

  1. templateFunction是一个模板函数，它可以接受任意类型的参数。无论传入的参数是int还是double，都不会进行类型转换，而是直接使用传入的参数类型。
  2. 而normalFunction是一个普通函数，它的参数类型是int。当我们传入一个double类型的参数时，编译器会自动进行隐式类型转换，将doubleValue的值转换成int类型，然后调用该函数。

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

2. 类模板

①类模板的定义格式

语法：

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

eg： 类模板中的函数放在类外进行定义时，就需要加模板参数列表

template<class T>
class vector     //把这个就当作一个数组的模板类
{
public:
	Vector(size_t capacity = 10)
		: _pData(new T[capacity])
		, _size(0)
		, _capacity(capacity)
	{}
	
	//类中声明，类外定义
	~vector();
private:
	T* _pData;
	size_t _size;
	size_t _capacity;
};

//加模板参数列表
template<class T>     //模板参数列表
Vector<T>::~Vector()
{
	if (_a)
	{
		delete[] _a;
	}
	_size = _capacity = 0;
}

②类模板的实列化

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

eg:

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

小结

  1. 模板最重要的一点就是类型无关，提高代码复用率
  2. 模板运行时不检查数据类型，也不保证类型安全，相当于类型的宏替换
  3. 只要支持模板语法，模板的代码就是可移植的。
  4. 模板的实参，在参数类型不同时，有时需要展示指定的类型参数
  5. 类模板是一个类家族，模板类是通过模板实列化的具体类。
  6. 类模板的虚拟类型是指类模板在使用时的占位类型
  7. 类模板的成员函数，全是模板函数。

三、class和typename区别

template<class Container>
void Print(const Container& v)
{
	Container::const_iterator it = v.begin();
	//...
}

分析代码：
class和typename使用

四、非类型模板参数

模板参数：类型形参和非类型形参

  1. 类型形参：出现在模板参数列表中，跟在class或者typename的参数类型
  2. 非类型形参：常量作为类（函数）模板的一个参数，在模板中可将该参数当常量使用

eg：

namespace kpl   //命名空间，有疑惑的可以看一下我前面写的博客
{
	//定义一个模板类型的静态数组
	template<class T, size_t N = 10>
	class array
	{
	public:
		T& operator[](size_t index)
		{
			return _array[index];
		}
		const T& operator[](size_t index) const
		{
			return _array[index];
		}

		size_t size() const
		{
			return _size;
		}
		bool empty() const
		{
			return 0 == _size;
		}

	private:
		T _array[N];
		size_t _size;
	};
}

int main()
{
	//想要静态存储10个，或者100个数据
	//array<int> a1;  存10个数据  
	//array<int> a2;  存100个数据  
	//为了解决上述问题，出现非类型模板参数
	kpl::array<int, 10> a1;     //kpl::array -> 使用命名空间的方式
	kpl::array<int, 100> a2;
	return 0;
}

非类型模板参数的限制：（了解）

  1. 浮点数、类对象以及字符串不允许作为非类型模板参数
  2. 非类型的模板参数必须在编译期间就能确认结果 。

五、类模板的特化

类模板的特化分为：函数模板特化和类模板特化

1. 概念

对于一些特殊类型，使用模板可能会得到一些错误的结果，所以就需要特殊处理

eg1：例子中借用自定义类型，日期类Date类的实现

template<class T>
bool Less(T left, T right)
{
	return left < right;
}

int main()
{
	cout << Less(1, 2) << endl;     //结果正确

	Date d1(2023, 8, 10);
	Date d2(2023, 8, 18);
	cout << Less(d1, d2) << endl;   //结果正确

	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;   //结果错误

	return 0;
}

代码分析：

  • 在上述这种场景下得到的结果错误。我们使用日期类指针比较，发现结果不是日期的比较而是指针的比较。
  • 为了解决上述问题就需要对模板进行特化。即在原模板类的基础上，针对特殊类型进行特殊化的实现方式

2. 函数模板特化

基本不使用函数模板特化，都是重新实现函数个函数即可

要求：

  1. 必须要先有一个基础的函数模板
  2. 关键字template后跟<>
  3. 函数名后跟<>，尖括号中指定需要特化的类型
  4. 函数形参表：必须和模板函数的基础参数类型完全相同。

eg1：例子中借用自定义类型日期类，Date类的实现

//函数模板
template<class T>
bool Less(T left, T right)
{
	return left < right;
}

//对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{
	return *left < *right;
}


int main()
{
	cout << Less(1, 2) << endl;

	Date d1(2023, 8, 10);
	Date d2(2023, 8, 18);
	cout << Less(d1, d2) << endl;

	Date* p1 = &d1;
	Date* p2 = &d2;
	cout << Less(p1, p2) << endl;    //调用特化版本，而不是走模板生成
}

注：一般如果函数模板遇到不能处理或处理有误的情况，为了实现简单，通常都是将该函数直接实现。（原因：实现简单，不易出错，后面的一些模板参数可能很复杂）
eg2：

bool Less(Date* left, Date* right)
{
	return *left < *right;
}

3. 类模板特化

①全特化

全特化即将模板参数列表中所有的参数都确定化

template<class T1, class T2>
class Data
{
public:
	Data()
	{
		cout << "Data<T1, T2>" << endl;
	}

private:
	T1 _d1;
	T2 _d2;
};

template<>
class Data<int, char>
{
public:
	Data()
	{
		cout << "Data<int, char>" << endl;
	}

private:
	int _d1;
	char _d2;
};


int main()
{
	Data<int, int> d1;
	Data<int, char> d2;
	return 0;
}

//output:
//Data<T1, T2>
//Data<int, char>

②偏特化

偏特化即任何针对模板参数进一步进行条件限制的特化版本

eg： 先给一个基础模板

template<class T1, class T2>
class Data
{
public:
	Data()
	{
		cout << "Data<T1, T2>" << endl;
	}

private:
	T1 _d1;
	T2 _d2;
};

偏特化的两种表现方式：

  1. 部分特化

将模板参数表一部分特化

//将第二个参数转成int
template<class T1>
class Data<T1, int>
{
public:
	Data()
	{
		cout << "Data<T1, int>" << endl;
	}

private:
	T1 _d1;
	int _d2;
};
  1. 参数进一步限制
//两个参数偏特化为指针类型
template<typename T1, typename T2>
class Data<T1*, T2*>
{
public:
	Data()
	{
		cout << "Data<T1*, T2*>" << endl;
	}

private:
	T1 _d1;
	T2 _d2;
};

//两个参数偏特化为引用类型
template<typename T1, typename T2>
class Data<T1&, T2&>
{
public:
	Data(const T1& d1, const T2& d2)
		:_d1(d1)
		,_d2(d2)
	{
		cout << "Data<T1&, T2&>" << endl;
	}

private:
	const T1& _d1;
	const T2& _d2;
};

偏特化代码测试：

int main()
{
	Data<double, int> d1;         //调用特化的int版本
	Data<int, double> d2;         //调用基础版本
	Data<int*, int*> d3;          //调用特化的指针版本
	Data<int&, int&> d4(1, 2);    //调用特化的引用版本
	return 0;
}

//output:
//Data<T1, int>
//Data<T1, T2>
//Data<T1*, T2*>
//Data<T1&, T2&>

六、模板的分离编译

1. 概念

分离编译模式：一个程序（项目）由若干个源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程

eg：

头文件声明: a.h

template<class T>
T Add(const T& left, const T& right);

源文件完成定义: a.cpp

template<class T>
T Add(const T& left, const T& right)
{
	return left + right;
}

在main函数调用Add： main.cpp

#include "a.h"
int main()
{
	Add(1, 2);
	Add(1.0, 2.0);
	return 0;
}

代码分析：
模板的分离编译

在模板的分离编译中，调用的地方只能看到声明而无法看到定义。模板的声明通常会被包含在头文件中，模板的定义实现通常会被放在源文件中。在编译器编译调用模板的文件时，只能看到声明部分，无法看到实现部分，因此无法进行实例化。要实例化模板，需要在模板的定义所在的源文件中显式实例化模板的具体类型。

2. 解决方法

  1. 在模板定义的位置显示实例化（不推荐）—— eg1

eg1：比较麻烦，需要什么类型的就要实例化一份

//这样上面的代码就可以正常运行了
template
class Add<int>;

template
class Add<double>;
  1. 将声明和定义放在一个文件中。例如同时放入xxx.hpp（.hpp的后缀表示声明和定义放在了一起）里面或者xxx.h也可以（推荐） —— eg2

eg2：

namespace kpl
{
	template<class T, class Container = std::deque<T>>
	class stack
	{
	public:
		//类中声明，类外定义，但是都在同一个文件
		void push(const T& x);
		void pop();
	private:
		Container _con;
	};

	//同一个文件中，在类外定义
	template<class T, class Container>
	void stack<T, Container>::push(const T& x)
	{
		_con.push_back(x);
	}

	template<class T, class Container>
	void stack<T, Container>::pop()
	{
		_con.pop_back();
	}
}

总结

  • 优点
    • 模板复用了代码，节约资源，更快的迭代开发
    • 增强了代码的灵活行
  • 缺点
    • 导致代码膨胀的问题，也导致编译时间长
    • 模板编译出现错误，错误信息长且乱，不便解决
kpl_20
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c++文件模板 c++文件模板
02-24
c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件模板 c++文件...
opencv模板C++版
10-16
opencv模板C++版
C++函数模板
weixin_44205961的博客
09-06 5016
模板是一个通用框架，是C++泛型编程思想的主要体现。C++提供了函数模板和类模板两种模板机制，本文介绍的是函数模板相关的知识。
c++ 模板
weixin_40026739的博客
06-16 1万+
模板是c++的一种特性，允许函数或者类（对象）通过泛型（generic types）的形式表现或者运行模板可以使得函数或类在对应不同的类型（types）的时候正常工作，而无需为每一种类型分别写一份代码。1：函数模板（function tempalte）：使用泛型参数的函数（function with generic parameters）2：类模板（class template）：使用泛型参数的类（class with generic parameters）模板的声明（declaration）其实并未给出一
c++模板函数
weixin_48984572的博客
09-06 2265
c++函数模板概念，重载，调用
c++ 定义模板
m0_56077202的博客
04-12 1499
定义模板 当定义一个比较函数时，因为参数类型包括int、float、char等等，若为每个类型都定义一个比较函数，就不得不重复定义完全一样的函数体，并且需要确定要比较的所有类型，就比较麻烦了。 函数模板 ： 以关键字开始 加一个模板参数列表 template <typename T> 这样就可以定义一个通用的函数模板，而不是为每一数据类型都定义一个新函数 template <typename T> int compare(const T &v1,const T &v
C++类模板
qq_45288949的博客
07-20 1869
类模板中的成员函数开始创建不出来，因为obj无法确定数据类型，直到调用才能确定T的数据类型。总结类模板和函数模板的语法相似，在声明模板template后面加类，此类称为类模板。typename——表示其后面的符号是一种数据类型，可以用class代替。总结类模板中的成员函数并不是一开始就创建的，在调用时才去创建。T——通用的数据类型，名称可以替换，通常为大写字母。template——声明创建模板。...
拓扑排序代码模板C++
weixin_43595277的博客
08-14 1954
算法步骤: ①定义一个队列Q，并把所有入度为0的结点加入队列。 ②取队首结点，输出。然后删去所有从它出发的边，并令这些边到达的顶点的入度减1，如果某个顶点的入度减为0，则将其加入队列。 ③反复进行②操作，直到队列为空。如果队列为空时入过队的结点数目恰好为N，说明拓扑排序成功，图G为有向无环图;否则，拓扑排序失败，图G中有环。 可使用邻接表实现拓扑排序。显然，由于需要记录结点的入度，因此需要额外建立一个数组inDegree[MAXV]，并在程序一开始读入图时就记录好每个结点的入度。接下来就只需要按上面所说.
C++模板详解
热门推荐
qq_52905520的博客
10-21 1万+
C++模板详解
C++之模板
m0_74893211的博客
06-22 4402
C++泛型编程和STL技术详细讲解。
C++ 函数模板基础
英雄哪里出来
05-22 3651
C++ 函数模板基础
C++模板
KevinJune的博客
06-01 793
1 模板的概念 模板就是建立通用的模具，大大提高复用性 例如生活中的模板 一寸照片模板 PPT模板等 模板的特点： ○模板不可以直接使用，它只是一个框架 ○模板的通用并不是万能的 2 函数模板 ○C++另一种编程思想称为 泛型编程， 主要利用的技术就是模板 ○C++提供两种模板机制：函数模板和类模板 2.1 函数模板语法 函数模板作用： 建立一个通用函数，其函数返回值类型和形参类型可以不具体指定，用一个虚拟的类型来代表。 语法： template<typename
程序员个人简历模板c++版
04-02
程序员个人简历模板c++版
C++ 模板函数
01-07
C++模板的使用可以提升代码的通用性、可移植性。方便通用库的开发。 与模板有关的关键字有两个： template 定义模板所用到的关键字。 typename 类型的名字，比如int，double，可以使用类类型，struck类型等。也可以...
C++模板元编程
01-06
C++模板元编程
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 913
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
clang frontEnd插件 常见Traverse函数、Visit函数 例子
_
05-17 69
clang插件
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 263
C语言如何在链表中的指定位置插⼊结点？
模板c++
05-30
以下是一个简单的 C++ 模板： ```cpp #include template T add(T a, T b) { return a + b; } int main() { std::cout (1, 2) ; // 输出 3 std::cout (3.5, 2.2) ; // 输出 5.7 return 0; } ``` 这个示例...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kpl_20

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值