C++模板（一）

已于 2024-01-21 21:42:29 修改
阅读量347 收藏 5
点赞数 7
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-01-21 21:42:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81389826/article/details/135735876
版权

目录

1、函数模板基本使用

2、函数模板和普通函数的调用规则

3、模板的局限性及解决

4、类模板的基本使用

5、类模板做函数参数

6、类模板碰到继承

7、类模板类外实现成员函数

1、函数模板基本使用
  • template < class / typename  T> 告诉编译器紧跟的代码里出现T不要报错
  • mySwap( T  &a,  T  &b ) 类型也需要传入 ，类型参数化
  • myswap（a,b） 自动类型推导  按照a b的类型 来替换T
  • myswap<int>(a,b) 显示指定类型
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
//交换int类型两个数字
void mySwapInt(int &a, int &b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
 
//交换double类型两个数字
void mySwapDouble(double &a, double &b)
{
	double tmp = a;
	a = b;
	b = tmp;
}
 
//类型，逻辑又非常相似
//类型参数化  泛型编程  --- 模板技术
template<class T>          //告诉编译器  下面如果出现T不要报错，T是一个通用的类型
void mySwap(T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}
 
//template<typename T>
//void mySwap2(T a){}
 
void test01()
{
	int a = 10;
	int b = 20;
	char c1 = 'v';
	//mySwapInt(a, b);
	//1、自动类型推到，必须有参数类型才可以推导
	//mySwap(a, c1);  报错 二义性 推导不出来T，所以不能运行
	mySwap(a, b);
 
	//2、显示指定类型
	mySwap<int>(a, b);
 
	//模板必须要指定出T，才可以使用   template<typename T> 等价于 template<class T>  
	//mySwap2();  错误
	//mySwap2<double>();
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
 
	
	double c = 3.14;
	double d = 5.21;
	//mySwapDouble(c, d);
	mySwap(c, d);
	cout << "c=" << c << endl;
	cout << "d=" << d << endl;
}
 
int main()
{
	test01();
	system("pause");
	return 0;
}

练习：使用函数模板对char和int类型数组进行排序。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
//对char和int数组进行排序 排序规则 从大到小 选择排序
template<class T>
void mySwap(T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}
 
template<class T>
void mySort(T arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		int max = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[max] < arr[j])
			{
				//交换
				max = j;
			}
		}
		if (max != i)
		{
			//交换数据
			mySwap(arr[max], arr[i]);
		}
	}
}
 
//输出数组元素的模板
template<class T>
void printArray(T arr[], int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}
 
void test01()
{
	char charArr[] = "helloworld";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);
 
	int intArr[] = { 1, 4, 100, 34, 55 };
	int num2 = sizeof(intArr) / sizeof(int);
	mySort(intArr, num2);
	printArray(intArr, num2);
}
 
int main()
{
	test01();
	system("pause");
	return 0;
}
2、函数模板和普通函数的调用规则
  • c++编译器优先考虑普通函数
  • 可以通过空模板实参列表的语法限定编译器只能通过模板匹配
  • 函数模板可以像普通函数那样可以被重载
  • 如果函数模板可以产生一个更好的匹配，那么选择模板

模板的机制

  1. 模板并不是万能的，不能通用所有的数据类型
  2. 模板不能直接调用，生成后的模板函数才可以调用
  3. 二次编译，第一次对模板进行编译，第二次对替换T类型后的代码进行二次编译
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
//1 普通函数与函数模板区别
template<class T>
T myPlus(T a, T b)
{
	return a + b;
}
 
 
int myPlus2(int a, int b)
{
	return a + b;
}
 
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	//myPlus(a, c); //类型推导不出来，函数模板不可以进行隐式类型转换
	myPlus(a, b);
	myPlus2(a, b);
	cout << myPlus2(a, c) << endl;  //10+99(‘c’的ASCII码值) 
	//普通函数 可以进行隐式函数类型转换
}
 
//2、普通函数和函数模板的调用规则
template<class T>
void myPrint(T a, T b)
{
	cout << "模板调用的myPrint" << endl;
}
 
 
template<class T>
void myPrint(T a, T b, T c)
{
	cout << "模板调用的myPrint(a,b,c)" << endl;
}
 
void myPrint(int a, int b)
{
	cout << "普通调用的myPrint" << endl;
}
 
 
void test02()
{
	int a = 10;
	int b = 20;
	//1、如果出现重载  优先使用普通函数的调用，如果没有实现，出现错误
	//myPrint(a, b);
 
	//2、如果想强制调用模板，那么可以使用空参数列表
	myPrint<>(a, b);
 
	//3、函数模板发生重载
	int c = 30;
	myPrint(a, b, c);
 
	//4、如果函数模板可以产生更好的匹配，那么优先调用函数模板
	char t = 'c';
	char u = 'd';
	myPrint(t, u);
}
 
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}
3、模板的局限性及解决

局限性

  • 模板不能解决所有的类型
  • 如果出现不能解决的类型，可以通过第三代具体化来解决问题
  • template<> 返回值 函数名<具体类型>（参数）
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
 
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	string m_Name;
	int m_Age;
};
 
template<class T>
bool myCompare(T &a, T &b)
{
	if (a == b)
	{
		return true;
	}
	return false;
}
 
//通过第三代具体化自定义数据类型，解决上述问题
//如果具体化能够优先匹配，那么就选择具体化
//语法  template<> 返回值  函数名<具体类型>(参数)
template<> bool myCompare<Person>(Person &a, Person &b)
{
	if (a.m_Age == b.m_Age)
	{
		return true;
	}
	return false;
}
void test01()
{
	int a = 10;
	int b = 20;
 
	int ret = myCompare(a, b);
	cout << "ret=" << ret << endl;
 
	Person p1("Tom", 10);
	Person p2("Jerry", 10);
 
	int ret2 = myCompare(p1, p2);
	cout << "ret2=" << ret2 << endl;
}
 
int main()
{
	test01();
	system("pause");
	return 0;
}
4、类模板的基本使用
  • 写法template <T…> 紧跟着是类
  • 与函数模板区别，可以有默认类型参数
  • 函数模板可以进行自动类型推导，而类模板不可以
  • 类模板中的成员函数 一开始不会创建出来，而是在运行时才去创建
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
 
//类模板
template <class NameType, class AgeType = int> //类模板可以有默认类型
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
 
	void showPerson()
	{
		cout << "姓名：" << this->m_Name << endl;
		cout << "年龄：" << this->m_Age << endl;
	}
 
	NameType m_Name;
	AgeType m_Age;
};
 
void test01()
{
	//自动类型推导，类模板 不支持
	//Person p("孙悟空",100);
 
	//显示指定类型
	Person<string, int>p("孙悟空", 100);
	p.showPerson();
}
 
 
class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1的调用" << endl;
	}
};
 
class Person2
{
public:
	void showPerson2()
	{
		cout << "Person2的调用" << endl;
	}
};
 
template<class T>
class myClass
{
public:
	T obj;
	void func1()
	{
		obj.showPerson1();
	}
	void func2()
	{
		obj.showPerson2();
	}
};
 
//成员函数 一开始不会创建出来，而是在运行时才去创建
void test02()
{
	myClass<Person1>m;
	m.func1();
	//m.func2();  showPerson2不是Person1的成员
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}
5、类模板做函数参数
  • 类模板做函数的参数
  •       三种方式
  •             显示指定类型
  •             参数模板化
  •             整体模板化
  •       查看类型名称
  •             cout << typeid(T).name() << endl;
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
 
//类模板
template <class NameType, class AgeType =int>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
 
	void showPerson()
	{
		cout << "姓名：" << this->m_Name << "  年龄：" << this->m_Age << endl;
	}
 
 
	NameType m_Name;
	AgeType m_Age;
};
 
//1、指定传入类型
void doWork(Person<string, int> & p)
{
	p.showPerson();
}
 
void test01()
{
	Person <string, int>p("MT", 10);
	doWork(p);
}
 
//2 参数模板化
template<class T1, class T2>
void doWork2(Person<T1, T2>&p)
{
	//如何查看类型
	cout << typeid(T1).name() << endl;
	cout << typeid(T2).name() << endl;
	p.showPerson();
}
 
 
void test02()
{
	Person<string, int>p("袋子", 18);
	doWork2(p);
}
 
//3 整体类型化
template<class T>
void doWork3(T&p)
{
	cout << typeid(T).name() << endl;
	p.showPerson();
}
void test03()
{
	Person<string, int>p("猎人", 18);
	doWork3(p);
}
 
 
int main()
{
	//test01();
	//test02();
	test03();
	system("pause");
	return 0;
}
6、类模板碰到继承
  • 基类如果是模板类，必须让子类告诉编译器 基类中的T到底是什么类型
  • 如果不告诉，那么无法分配内存，编译不过
  • 利用参数列表class Child :public Base<int>
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
 
template<class T>
class Base
{
public:
	T m_A;  //double类型
};
 
//child继承于base 必须告诉base中的T的类型，否则T无法分配内存
class Child :public Base<int>   //说明T是int类型
{
 
};
 
//Child2也是模板类
template<class T1, class T2>
class Child2 :public Base<T2>
{
public:
	Child2()
	{
		cout << typeid(T1).name() << endl;
		cout << typeid(T2).name() << endl;
	}
public:
	T1 m_B;  //int类型
};
 
void test01()
{
	Child2<int, double>child; //由用户指定类型
}
 
int main()
{
	test01();
	system("pause");
	return 0;
}
7、类模板类外实现成员函数
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
using namespace std;
 
template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age);
	/*{
		this->m_Name = name;
		this->m_Age = age;
	}*/
 
	void showPerson();
	/*{
		cout << "姓名：" << this->m_Name << "  年龄：" << this->m_Age << endl;
	}*/
 
	T1 m_Name;
	T2 m_Age;
};
 
//类外实现成员函数
template<class T1,class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}
 
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名：" << this->m_Name << "  年龄：" << this->m_Age << endl;
}
 
void test01()
{
	Person<string,int> p1("MT", 100);
	p1.showPerson();
}
 
 
int main()
{
	test01();
	system("pause");
	return 0;
}

鄠邑原野
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++ 定义模板
m0_56077202的博客
04-12 1567
定义模板 当定义一个比较函数时，因为参数类型包括int、float、char等等，若为每个类型都定义一个比较函数，就不得不重复定义完全一样的函数体，并且需要确定要比较的所有类型，就比较麻烦了。 函数模板 ： 以关键字开始 加一个模板参数列表 template <typename T> 这样就可以定义一个通用的函数模板，而不是为每一数据类型都定义一个新函数 template <typename T> int compare(const T &v1,const T &v
C++ 模板类的嵌套
man_skill的博客
04-10 3197
模板类的嵌套 使用函数模板，当参数是自定义数据类型（如结构体，类）时，需要通过第三代具体化自定义数据类型来解决问题。 那么对于类模板中的成员对象的数据类型也是自定义数据类型呢。 实际上，只要类中包括了某个类型的成员或者方法，在实例化对象的时候就要声明数据类型。 那么如果类的成员也是模板类呢。 就出现了如下的嵌套： template<class T> class Nm { T a; }; template<class T> class Mn { T find() { T p
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_44205961的博客
09-06 5353
模板是一个通用框架，是C++泛型编程思想的主要体现。C++提供了函数模板和类模板两种模板机制，本文介绍的是函数模板相关的知识。
C++模板——template
热门推荐
原来45的博客
06-11 3万+
目录1. 模板2. 函数模板2.1 函数模板概念2.2 函数模板格式2.3 函数模板原理2.4 函数模板的实例化2.5 模板参数的匹配原则2.6 声明定义分离3. 类模板3.1 类模板格式3.2 类模板的实例化3.3 类模板中函数放在类外进行定义时4. 模板分离编译4.1 什么是分离编译4.2 模板的分离编译5. 缺省值，返回值6. 总结...
c++模板函数
weixin_48984572的博客
09-06 2422
c++函数模板概念，重载，调用
C++模板的使用
zzfzzfzzffzz的博客
09-06 2537
C++提供了函数模板(function template.)所谓函数模板,实际上是建立一个通用函数，函数类型和形参类型不具体制定，用一个虚拟的类型来代表。C++提供两种模板机制:函数模板和类模板。但是在C++中使用模板这样做会出现连接错误，原因：函数模板是在调用时确定的版本，而调用时.h中没有函数实现，出现连接错误，找不到函数体，如果分开后，编译会出现连接错误。（2）如果有普通函数和模板函数都能匹配优先调用模板函数，如在调用时用显示调用（省略类型的方式 swap_all(1,2))则会调用模板函数。
C++ 模板
weixin_44235615的博客
03-19 1729
基本概念：模板就是建立通用的模具，大大提高代码的复用性。 特点： 模板不可以直接使用，只是一个框架 模板的通用并不是万能的 泛型编程主要利用的思想就是模板 模板分为函数模板和类模板 总结： 函数模板利用关键字template 使用函数模板有两种方式：自动类型推导、显示指定类型 模板的目的是为了提高复用性，将类型参数化 注意事项： 自动类型推导，必须推导出一致的数据类型T，才可以使用 模板必须要确定出T的数据类型，才可以使用 普通函数与函数模板的区别： 普通函数调用时可以发生自动类型转换
C++模板特化
习惯有你
12-24 1447
模板特化 在学习模板的时候我们用模板来解决了一个add模板函数，实现不同类型的传参相加，实践证明，模板函数比普通函数好用。那么现在如果我们要新增一个需求，就是如果传入的是两个string类型的参数，我们不要简单的拼接，我们要在两个字符串之间添加一个空格，显然模板函数已经无法满足我们的要求，解决方法就是使用模板特化，简单说就是模板的一个特殊化，当传参为两个string类型的时候，不调用模板函数，而是调用特化模板函数，传入其它类型的时候，仍然使用模板函数，如下示例： template &l...
C++ 函数模板基础
英雄哪里出来
05-22 3924
C++ 函数模板基础
C++模板元编程
01-06
#### 一、C++模板元编程概述 在现代软件开发领域，C++模板元编程（Template Metaprogramming）是一种利用C++编译器的类型系统来实现计算逻辑的技术。它允许程序员在编译时执行复杂的算法和数据处理任务，而无需运行...
由浅入深学习C++模板
11-21
模板练习 ├─Macro1 │ └─res ├─Macro2 │ └─res ├─Macro3 │ └─res ├─Template1 ├─Template2 ├─Template3 ├─Template4 ├─Template5 ├─函数指针模板 │ ├─FuncTemplate1 │ ├─...
C++ 模板函数
01-07
C++模板的使用可以提升代码的通用性、可移植性。方便通用库的开发。 与模板有关的关键字有两个： template 定义模板所用到的关键字。 typename 类型的名字，比如int，double，可以使用类类型，struck类型等。也可以...
c++模板详细描述
01-05
c++模板详细描述
C++模板与STL库介绍
03-18
C++模板和STL库是C++编程语言中的两个核心特性，它们极大地提高了代码的复用性和效率。本文将深入探讨这两个主题，并提供丰富的实践应用示例。 首先，我们来理解C++模板。模板是C++的一个强大工具，它允许程序员...
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
最新发布
qq_19319481的博客
08-09 317
使用vtkRenderer创建的显示点云的窗口如何刷新(QT/C++)
c++ error: ‘*’ does not name a type； did you mean ‘**’?
xiaozhi
08-08 460
c++ error: ‘*’ does not name a type； did you mean ‘**’?
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 347
STL中的迭代器失效（vector为例）
C++ STL专题 list的讲解
Mike的博客
08-07 779
1.list是可以在常数范围内任意位置进行插入和删除的序列式容器，并且可以前后双向迭代。2. list的底层是双链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代。4. 与其他的序列式容器相比(vector，deque), list通常在任意位置进行插入，移除元素的执行效率更好。5. 与其他序列式容器相比，
C++模板元编程深度探索
C++模板元编程是一种在编译时进行计算和逻辑处理的技术，它是利用C++的模板机制来实现的一种形式化的编程方法。这种技术允许程序员通过模板来生成和操作类型和表达式，从而创建高度泛化且高效的代码。在C++中，模板...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值