C++泛型编程-模板

已于 2023-06-19 22:21:17 修改
阅读量108 收藏 1
点赞数
分类专栏： C++ 文章标签： c++
于 2023-06-19 00:23:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kunjpg/article/details/131278274
版权

1. 模板

C++泛型编程和STL技术

1.1 模板的概念

模板就是建立通用的摸具，大大提高复用性

模板的特点：

  • 不可直接使用，只是一个框架
  • 通用并不是万能的

1.2 函数模板

  • C++另一种编程思想称为泛型编程 主要利用的技术就是模板
  • 提供两种模板机制：函数模板和类模板

1. 函数模板语法

作用：建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来表示

语法：

template<typename T>
函数声明或定义

解释：

  • template 声明创建模板
  • typename 表面其后面的符号是一种数据类型，可以用class替代
  • T 通用数据类型，名称可以替代，通常为大写字母

示例：

//交换两个整型函数
void swapInt(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
}

//交换两个浮点型函数
void swapDouble(double &a, double &b)
{
	double temp = a;
	a = b;
	b = temp;
}

//交换函数模板
template<typename T>	//声明一个模板，告诉编译器后面代码中紧跟的T不要报错
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

void test01()
{
	int a = 10;
	int b = 20;
	//swapInt(a, b);
	//利用函数模板交换
	//两种方式使用函数模板
	//1、自动类型推导
	mySwap(a, b);
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	double c = 1.1;
	double d = 2.2;
	//swapDouble(c, d);
	//2、显示指定类型
	mySwap<double>(c, d);
	cout << "c=" << c << endl;
	cout << "d=" << d << endl;
}
int  main()
{
	test01();
	system("pause");
	return 0;
}

总结：

  • 函数模板利用关键字 template
  • 使用函数模板有两种方式：自动类型推导，显示指定类型
  • 模板的目的是为了提高复用性，将类型参数化

2. 函数模板注意事项

  • 自动类型推导，必须推导出一致的数据类型T，才可以使用
  • 模板必须确定T的数据类型，才可以使用

示例：

template<class T>		//typename 可以替换为 class
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

template<class T>
void func()
{
	cout << "func的调用" << endl;
}

void test01()
{
	int a = 10;
	int b = 20;

	char c = 'c';

	//mySwap(a, c);	//error 推导不出一致的T类型
	mySwap(a, b);
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	//func();	//error 模板必须确定T的数据类型，才可以使用
	func<int>();
}
int  main()
{
	test01();
	system("pause");
	return 0;
}

3. 函数模板案例

案例描述：

  • 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
  • 排序规则从大到小，排序算法为选择排序
  • 分别利用char数组和int数组进行测试

示例：

//交换函数模板
template<class T>
void mySwap(T &a, T &b)
{
	T temp = a;
	a = b;
	b = temp;
}

//排序算法
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)
		{
			//交换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数组
	char charArr[] = "agfgsd";
	int num = sizeof(charArr) / sizeof(charArr[0]);
	mySort(charArr, num);
	printArray(charArr, num);
}

void test02()
{
	//测试int数组
	int intArr[] = { 7,5,1,3,9,44 };
	int num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	printArray(intArr, num);
}

int  main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

4. 普通函数与函数模板的区别

  • 普通函数调用时可以发生自动类型转化（隐式类型转化）
  • 函数模板调用时候，如果利用自动类型推导，不会发生隐式类型转化
  • 如果利用显示指定类型的方式，可以发生隐式类型转化

示例：

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

template<class T>
T myAdd2(T a, T b)
{
	return a + b;
}
//普通函数调用可以发生隐式类型转化
void test01()
{
	int a = 10;
	int b = 20;
	char c = 'c';
	cout << myAdd01(a, c) << endl;	//109,将c转换成整型

	//自动类型推导
	cout << myAdd2(a, b) << endl;
	//函数模板用自动类型推导，不可以发生隐式类型转化
	//cout << myAdd2(a, c) << endl;	//error

	//显式指定类型
	//函数模板用显式指定类型，可以发生隐式类型转化
	cout << myAdd2<int>(a, c) << endl;	//109
}


int  main()
{
	test01();
	system("pause");
	return 0;
}

总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型

5. 普通函数与函数模板的调用规则

调用规则如下：

  • 如果函数模板和普通函数都可以实现，优先调用普通函数
  • 可以通过空模板参数列表来强制调用函数模板
  • 函数模板可以发生重载
  • 如果函数模板可以产生更好的匹配，优先调用函数模板

示例：

void myPrint(int a, int b)
{
	cout << "调用的普通函数" << endl;
}

//- 函数模板可以发生重载
template<class T>
void myPrint(T a, T b)
{
	cout << "调用的模板函数" << endl;
}

template<class T>
void myPrint(T a, T b,T c)
{
	cout << "调用的重载模板函数" << endl;
}

void test01()
{
	int a = 10;
	int b = 20;
	//- 如果函数模板和普通函数都可以实现，优先调用普通函数
	//myPrint(a, b);		//调用的普通函数

	//- 可以通过空模板参数列表来强制调用函数模板
	myPrint<>(a, b);		//调用的模板函数

	myPrint(a, b, 100);		//调用的重载模板函数

	//- 如果函数模板可以产生更好的匹配，优先调用函数模板
	char x1 = 'a';
	char x2 = 'b';
	myPrint(x1, x2);		//调用的模板函数
}

int  main()
{
	test01();
	system("pause");
	return 0;
}

总结：提供了函数模板，最好就不要提供普通函数了，否则容易出现二义性

6. 模板的局限性

如果传入自定义数据类型，一般模板是无法正常运行的

为了解决这个问题，C++提供了模板的重载，可以为这些特定的类型提供具体化的模板

示例：

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;
	else
		return false;
}

//利用具体化的Person版本实现代码，具体化优先调用
template<>bool myCompare(Person &p1, Person &p2)
{
	if (p1.m_name == p2.m_name&&p1.m_age == p2.m_age)
		return true;
	else
		return false;
}

void test01()
{
	int a = 10;
	int b = 20;
	bool result = myCompare(a, b);
	if (result)
	{
		cout << "a==b" << endl;
	}
	else
		cout << "a!=b" << endl;
}

void test02()
{
	Person p1("Tom", 10);
	Person p2("Jary", 10);
	//具体化优先调用
	bool ret = myCompare(p1, p2);
	if (ret)
		cout << "p1=p2" << endl;
	else
		cout << "p1!=p2" << endl;
}
int  main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

总结：

  • 利用具体化的模板，可以解决自定义类型的通用化

1.3 类模板

1. 类模板语法

类模板作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来表示

语法：

template<typename T>
类

解释：

  • template 声明创建模板
  • typename 表面其后面的符号是一种数据类型，可以用class替代
  • T 通用数据类型，名称可以替代，通常为大写字母

示例：

//类模板
template<class NameType,class AgeType>
class Person
{
public:
	Person(NameType name, AgeType age)
	{
		this->m_name = name;
		this->m_age = age;
	}
	void showPerson()
	{
		cout << "name:" << this->m_name << endl;
		cout << "age:" << this->m_age << endl;
	}
	NameType m_name;
	AgeType m_age;
};

void test01()
{
	Person<string, int> p1("Tom", 11);
	p1.showPerson();
}

int  main()
{
	test01();
	system("pause");
	return 0;
}

总结：类模板和函数模板语法相似，再声明模板template后面加类，此类称为类模板

2. 类模板和函数模板的区别

类模板和函数模板的区别

  • 类模板没有自动类型推导的使用方式
  • 类模板在模板参数列表中可以有默认参数

示例：

//类模板
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 << "name:" << this->m_name << endl;
		cout << "age:" << this->m_age << endl;
	}
	NameType m_name;
	AgeType m_age;
};

void test01()
{
	//Person p("Tom", 11);	//error 类模板没有自动类型推导的使用方式
	Person<string, int> p("Tom", 11);
	p.showPerson();
}

void test02()
{
	//- 类模板在模板参数列表中可以有默认参数
	Person<string> p2("Jary", 11);
	p2.showPerson();

}
int  main()
{
	test01();
	system("pause");
	return 0;
}

3. 类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的

  • 普通类中的成员函数一开始就可以创建
  • 类模板中的成员函数在调用时才会创建
class Person1
{
public:
	void showPerson1()
	{
		cout << "Person1 show" << endl;
	}
};

class Person2
{
public:
	void showPerson2()
	{
		cout << "Person1 show" << endl;
	}
};

template<class T>
class MyClass
{
public:
	T obj;
	//类模板中的成员函数
	void func()
	{
		obj.showPerson1();
	}
	void func2()
	{
		obj.showPerson2();
	}
};

void test01()
{
	//类模板中的成员函数不是一开始就创建的，而是在模板调用时再生成
	MyClass<Person1> m;
	m.func();
	//m.func2(); error
}

int  main()
{
	test01();
	system("pause");
	return 0;
}

4. 类模板对象做函数参数

  • 类模板实例化出的对象，向函数传参的方式

一共三种传入方式：

  • 指定传入的类型 直接显示对象的数据类型（常用）
  • 参数模板化 将对象中的参数变为模板进行传递
  • 整个类模板化 将这个对象类型模板化进行传递

示例：

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 << endl;
		cout << "年龄：" << this->m_age << endl;
	}
	T1 m_name;
	T2 m_age;
};

//- 指定传入的类型  直接显示对象的数据类型
void printPerson1(Person<string, int> &p)
{
	p.showPerson();
}
void test01()
{
	Person<string, int> p("胡图图", 23);
	printPerson1(p);
}

//- 参数模板化          将对象中的参数变为模板进行传递
template<class T1,class T2>
void printPerson2(Person<T1, T2> &p)
{
	p.showPerson();
	cout << "T1的类型为：" << typeid(T1).name() << endl;
	cout << "T2的类型为：" << typeid(T2).name() << endl;
}

void test02()
{
	Person<string, int> p("小美", 23);
	printPerson2(p);
}

//- 整个类模板化       将这个对象类型模板化进行传递
template<class T>
void printPerson3(T &p)
{
	p.showPerson();
}

void test03()
{
	Person<string, int> p("壮壮哥哥", 26);
	printPerson3(p);
}

int  main()
{
	test01();
	test02();
	test03();
	system("pause");
	return 0;
}

typeid(T2).name() 查看数据类型

5. 类模板与继承

当类模板碰到继承，需要注意以下几点

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T 的类型
  • 如果不指定，编译器无法给子类分配内存
  • 如果向灵活指定父类中T的类型，子类也需要变成类模板

示例：

template<class T>
class Base
{
	T m;
};

//- 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T 的类型
//- 如果不指定，编译器无法给子类分配内存
//class Son :public Base	//error 必须知道父类中T的类型，才能继承给子类
class Son:public Base<int>
{

};

void test01()
{
	Son s1;
}

//- 如果向灵活指定父类中T的类型，子类也需要变成类模板
template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
	Son2()
	{
		cout << "T1的类型为：" << typeid(T1).name() << endl;
		cout << "T2的类型为：" << typeid(T2).name() << endl;
	}
	T1 obj;
};

void test02()
{
	Son2<int, char> S2;
}

int  main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

总结：如果父类是类模板，子类需要指定父类中T的数据类型

6. 类模板成员函数类外实现

示例：

template<class T1,class T2>
class Person
{
public:
	Person(T1 name, T2 age);

	void showPerson();

	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 << "name:" << this->m_name << "  ";
	cout << "age:" << this->m_age << endl;
}

void test01()
{
	Person<string, int> p("Hututu", 23);
	p.showPerson();
}

int  main()
{
	test01();
	system("pause");
	return 0;
}

总结：类模板中成员函数类外实现时，需要加上模板参数列表

7. 类模板分文件编写

Q：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

A：

  • 直接包含.cpp源文件
  • 将声明和实现写到同一个文件中，并将后缀名改为.hpp，hpp是约定的名称，不是强制

直接包含.cpp文件：

//person.h
#pragma once
#include<iostream>
#include<string>
using namespace std;

template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);

	void showPerson();

	T1 m_name;
	T2 m_age;
};
//----------------------------------------------------------------------------------
//person.cpp
#include"person.h"

//构造函数的类外实现
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 << "name:" << this->m_name << "  ";
	cout << "age:" << this->m_age << endl;
}
//----------------------------------------------------------------------------------
//main
#include<iostream>
#include<string>
using namespace std;
//第一种解决方式，直接包含源文件.cpp
include"person.cpp"

void test01()
{
	Person<string, int> p("hututu", 23);
	p.showPerson();
}
int  main()
{
	test01();
	system("pause");
	return 0;
}

将声明和实现写到同一个文件中，并将后缀名改为.hpp

//person.hpp
#pragma once
#include<iostream>
#include<string>
using namespace std;

template<class T1, class T2>
class Person
{
public:
	Person(T1 name, T2 age);

	void showPerson();

	T1 m_name;
	T2 m_age;
};

//main
#include<iostream>
#include<string>
using namespace std;

//第二种解决方式，将.h和.cpp中的内容写到一起，将后缀名改为.hpp
#include"person.hpp"

void test01()
{
	Person<string, int> p("hututu", 23);
	p.showPerson();
}
int  main()
{
	test01();
	system("pause");
	return 0;
}

8. 类模板和友元

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

示例：

//提前让编译器知道Person类的存在
template<class T1, class T2>
class Person;

//全局函数类外实现,需要让编译器提前知道这个函数的存在
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)
{
	cout << "类外实现" << endl;
	cout << "name:" << p.m_name << "  ";
	cout << "age:" << p.m_age << endl;
}

//通过全局函数打印 Person信息
template<class T1,class T2>
class Person
{
	//全局函数类内实现
	friend void printPerson(Person<T1,T2> p)
	{
		cout << "name:" << p.m_name << "  ";
		cout << "age:" << p.m_age << endl;
	}
	//全局函数类外实现
	//加空模板的参数列表
	//如果全局函数是类外实现，需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(Person<T1, T2> p);

public:
	Person(T1 name, T2 age)
	{
		this->m_name = name;
		this->m_age = age;
	}
private:
	T1 m_name;
	T2 m_age;
};

//1、全局函数在类内实现
void test01()
{
	Person<string, int> p("Tom", 23);
	printPerson(p);
}

//2、全局函数在类外实现
void test02()
{
	Person<string, int> p("Jerry", 23);
	printPerson2(p);
}

int  main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

总结：建议使用全局函数类内实现，用法简单，而且编译器可以自动识别

你不困我困
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++系列-泛型编程与模板-源码
05-24
c++系列-泛型编程与模板-源码
C++模板
weixin_63246738的博客
05-19 5413
c++的模板
C++模板详解
qq_52905520的博客
10-21 1万+
C++模板详解
C++模板（template）详解
2301_81261654的博客
03-09 3116
原因是在链接过程中，编译器找不到模板函数的定义，因为在使用模板时，.h文件中的模板的声明知晓了模板参数的类型，但在.cpp文件中的模版不知道，所以.cpp中模板的定义没法实例化,也就没法在编译阶段生成一份经过实例化的具体的代码，这将导致程序在链接阶段找不到模板函数的实现而报链接错误。这样一来，在调用Add函数的时候，其本质上是调用了上面的经过实例化的模板函数，这样做的好处就是，程序员就可以不用对每一种数据类型都去实现对应的函数，大大提高了效率，而且只实现这么一份通用的模板函数可以使其更易于维护。
C++之模板
m0_74893211的博客
06-22 4419
C++泛型编程和STL技术详细讲解。
C++——模板（超详细的模板解析）
热门推荐
JAN6055的博客
04-01 5万+
超详细的C++模板知识列表，持续维护。
C++ 泛型编程详解
01-21
这一篇介绍一下 C++ 编程中与面向对象并列的另一大分支——泛型编程，这一篇主要介绍函数模板、类模板和成员模板三大部分 如有侵权，请联系删除，如有错误，欢迎大家指正，谢谢 泛型编程 模板是泛型编程的一种重要...
C++程序设计与实践：11-模板和泛型编程.ppt
06-12
C++程序设计与实践：11-模板和泛型编程.ppt
C++泛型编程，学习总结方便回看！
最新发布
05-15
C++泛型编程，联系代码手稿。容器、模版、STL：string、vector、deque、stack、queue、list、map、set，函数对象：仿函数、谓词、常见库算法：遍历、查找、排序
【C++】—— 模板介绍
m0_56069910的博客
06-08 2051
模板的详细介绍
（B站黑马C++）模板
IT OR 考公？
07-07 1444
记录代码，只用于复习
c++—模板（函数模板、类模板）
m0_72814368的博客
05-25 2191
c++—模板（函数模板、类模板）
c++模板
yaoyaohyl的博客
10-20 758
+。很多时候，由于程序员低估了模板实例化展开的开销，因此大量的模板使用会在代码中产生大量的余。这种余，有的时候已经使得编译器和链接器力不从心。++
C++模板详解：泛型编程、模板原理、非类型模板参数、模板特化、分离编译
林慢慢的博客
06-01 1567
泛型编程、模板原理、非类型模板参数、模板特化、分离编译
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++之模板编程
u010378559的博客
05-04 1876
C++模板编程总结
C++泛型编程和apollo
04-30
C++ 泛型编程是一种利用模板来实现代码复用和泛化的技术，可以大大提高代码的灵活性和重用性。C++的模板机制非常强大，可以实现各种高级的泛型编程技巧，比如模板元编程、SFINAE技术等。而在C语言中，由于没有模板...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值