模板-C++提高编程

于 2025-03-15 14:35:42 发布
阅读量705 收藏 30
点赞数 24
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_84315007/article/details/146203404
版权

C++的一种编程思想称为泛型编程，用到的技术就是模板

C++提供两种模板：函数模板和类模板。

1.函数模板

1.函数模板作用

建立一个通用函数，其返回值类型和形参类型可以用一个虚拟的类型来代替,提高代码复用性，将类型参数化。

2.语法

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

template--声明创建模板

typename--表明其后面的符号是一种数据类型，可以用class代替

T--通用的数据类型，名称可以替换，通常为大写字母

3.例子

未应用模板（代码复杂，通用性差）

void intswap(int& a, int& b)
{
	int c;
	c = a;
	a = b;
	b = c;
}
void doubleswap(double& a, double& b)
{
	double c;
	c = a;
	a = b;
	b = c;
}

应用模板（代码简洁，通用性强）

注意：函数模板一次只能对应一个函数，也就是说T不能多次重复使用

template<typename T>
void swap(T& a, T& b)
{
	T c;
	c = a;
	a = b;
	b = c;
}

4.模板使用方式

1.自动类型推导

swap(a,b)；

2.显示指定类型

swap<int>(a,b)；

5.注意事项

1.自动类型推导

必须推导出一只的数据类型T才可以使用

反例：

#include<iostream>
using namespace std;
#include<string>
template<typename T>
void swap(T& a, T& b)
{
	T c;
	c = a;
	a = b;
	b = c;
}
int main()
{
	int a=0;
	char b = '12';
	swap(a, b);
	return 0;
}

2.T的类型必须确定

模板必须要确定T的类型，才可以使用

反例：

#include<iostream>
using namespace std;
#include<string>
template<typename T>
void swap()
{
	cout << "swap" << endl;
}
int main()
{
	swap();
	return 0;
}

6.案例

1.题目

对数组进行降序排序

2.代码
#include<iostream>
using namespace std;
#include<string>
template<typename T>
void sort(T a[],int len)
{
	T temp;
	int max ;
	for (int i = 0; i < len; i++)
	{
		max = i;
		for (int j = i; j < len; j++)
		{
			if (a[j] > a[max])
			{
				temp = a[j];
				a[j] = a[max];
				a[max] = temp;
			}
		}
	}
}
int main()
{
	char c[6] = "badce";
	sort(c,5);
	cout << c << endl;
	int a[6] = {4,5,2,3,1};
	sort(a, 5);
	for(int i=0;i<5;i++)
	cout << a[i] << endl;
	return 0;
}
3.结果

7.普通模板与函数模板区别

·普通函数可以发生自动类型转换（隐式类型转换）

·函数模板调用时，如果利用自动类型推导，则不会发生隐式类型转换

·如果利用显示指定类型的方式，可以发生隐式类型转换

1.普通函数隐式类型转换
#include<iostream>
using namespace std;
#include<string>
int fun(int a, int b)
{
	return a + b;
}
int main()
{
	int a = 10;
	char c = 'c';//a=97,c=99
	cout << fun(a, c) << endl;
	return 0;
}

2.自动类型推导不可以使用
#include<iostream>
using namespace std;
#include<string>
template<typename T>
int fun(T a, T b)
{
	return a + b;
}
int main()
{
	int a = 10;
	char c = 'c';
	cout << fun(a, c) << endl;
	return 0;
}

3.显式指定类型可以使用
#include<iostream>
using namespace std;
#include<string>
template<typename T>
int fun(T a, T b)
{
	return a + b;
}
int main()
{
	int a = 10;
	char c = 'c';
	cout << fun<int>(a, c) << endl;
	return 0;
}

4.建议

建议使用显式指定类型的方式调用，这种更加明确。

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

1.函数模板可以发生重载
1.普通函数与函数模板重载
#include<iostream>
using namespace std;
#include<string>
template<typename T>
void fun(T a)
{
	cout << "函数模板" << endl;
}
void  fun()
{
	cout << "普通函数" << endl;
}
int main()
{
	fun(1);
	fun();
	return 0;
}

2.函数模板之间的重载
#include<iostream>
using namespace std;
#include<string>
template<typename T>
void fun(T a)
{
	cout << "函数模板" << endl;
}
template<typename T>
void fun(T a,T b)
{
	cout << "重载函数模板" << endl;
}
int main()
{
	fun(1);
	fun(1, 1);
	return 0;
}
2.调用优先级

如果普通函数和函数模板都可以调用，优先调用函数模板

#include<iostream>
using namespace std;
#include<string>
template<typename T>
void fun(T a)
{
	cout << "函数模板" << endl;
}
void  fun( int a)
{
	cout << "普通函数" << endl;
}
int main()
{
	fun(1);
	return 0;
}

注意：就算普通函数只有一个声明也不会调用函数模板（会报错）。

#include<iostream>
using namespace std;
#include<string>
template<typename T>
void fun(T a)
{
	cout << "函数模板" << endl;
}
void  fun(int a);
int main()
{
	fun(1);
	return 0;
}

3.强制调用模板函数

通过空模板参数列表，强制调用函数模板

fun<>(1);
4.发生隐式类型转换时的优先级

当普通函数发生隐式类型转换时，会优先调用函数模板（程序会使用最优选择）

#include<iostream>
using namespace std;
#include<string>
template<typename T>
void fun(T a)
{
	cout << "函数模板" << endl;
}
void fun(char a)
{
	cout << "普通函数调用" << endl;
}
int main()
{
	fun(1);
	return 0;
}

2.类模板

1.定义

建立一个通用类，类中的成员数据类型可以不具体指定，用一个虚拟的类型来代替。

2.语法

template<typename T>
//类

template--声明创建模板

typename--表明其后面的符号是一种数据类型，可以用class代替

T--通用的数据类型，名称可以替换，通常为大写字母

3.例子

#include<iostream>
using namespace std;
#include<string>
template<class A,class B>
class person
{
public:
	person(A name, B age)
	{
		this->name = name;
		this->age = age;
	}
	void show()
	{
		cout << this->name << this->age << endl;
	}
	A name;
	B age;
};
int main()
{
	person<string, int>p1("孙悟空", 999);
	p1.show();
	return 0;
}

4.类模板与函数模板区别

1.类模板不可以使用自动类型推导，只能自己设置类型。

2.类模板的模板参数列表中可以默认参数

模板参数表:即为尖括号里面的

template<class A,class B>

默认参数

template<class A,class B=int>

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

只要不去调用，就不会创建，所以a.fun()不会报错

#include<iostream>
using namespace std;
#include<string>
template<class A>
class person
{
public:
	A a;
	void fun()
	{
		a.fun1();
	}
};
int main()
{
	return 0;
}

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

#include<iostream>
using namespace std;
#include<string>
template<class A,class B>
class person
{
public:
	A name;
	B age;
	person(A name, B age)
	{
		this->name = name;
		this->age=age;
	}
	void show()
	{
		cout << this->name << endl;
		cout << this->age << endl;
	}
};
void fun(person<string, int>&p1)
{
	p1.show();
}
int main()
{
	person<string, int>p1("孙悟空", 100);
	fun(p1);
	return 0;
}

此时的函数参数应该是“person<string, int>&p1”

7.函数模板参数模板化

使用函数模板来提高复用性

#include<iostream>
using namespace std;
#include<string>
template<class A,class B>
class person
{
public:
	A name;
	B age;
	person(A name, B age)
	{
		this->name = name;
		this->age=age;
	}
	void show()
	{
		cout << this->name << endl;
		cout << this->age << endl;
	}
};
template<class T1,class T2>
void fun(person<T1, T2>&p1)
{
	p1.show();
}
int main()
{
	person<string, int>p1("孙悟空", 100);
	fun(p1);
	return 0;
}

1.类型显示方法

如果想显示出自动类型转换的类型是什么，可以用这个方法

#include<iostream>
using namespace std;
#include<string>
template<class A,class B>
class person
{
public:
	A name;
	B age;
	person(A name, B age)
	{
		this->name = name;
		this->age=age;
	}
	void show()
	{
		cout <<"姓名:" << this->name << endl;
		cout << "年龄:" << this->age << endl;
	}
};
template<class T1,class T2>
void fun(person<T1, T2>&p1)
{
	p1.show();
	cout <<"T1的类型：" << typeid(T1).name() << endl;
	cout <<"T2的类型：" << typeid(T2).name() << endl;
}
int main()
{
	person<string, int>p1("孙悟空", 100);
	fun(p1);
	return 0;
}

8.将做参数的整个类都模板化

#include<iostream>
using namespace std;
#include<string>
template<class A,class B>
class person
{
public:
	A name;
	B age;
	person(A name, B age)
	{
		this->name = name;
		this->age=age;
	}
	void show()
	{
		cout <<"姓名:" << this->name << endl;
		cout << "年龄:" << this->age << endl;
	}
};
template<class T>
void fun(T &p1)
{
	p1.show();
	cout << "T的数据类型：" << typeid(T).name() << endl;
}
int main()
{
	person<string, int>p1("孙悟空", 100);
	fun(p1);
	return 0;
}

9.类模板与继承

父类如果是一个模板，子类在继承时需要指出他的数据类型

1.手动指定数据类型
#include<iostream>
using namespace std;
#include<string>
template<class T>
class base
{
public:
	T a;
};
class son :public base<int>
{

};
int main()
{
	return 0;
}
2.将子类也变为模板
#include<iostream>
using namespace std;
#include<string>
template<class T>
class base
{
public:
	T a;
};
template<class T1,class T2>
class son :public base<T2>
{
public:
	T1 a;
};
int main()
{
	son<string, int>p1;
	return 0;
}

10.类模板的函数类外实现

1.构造函数的类外实现
#include<iostream>
using namespace std;
#include<string>
template<class T1,class T2>
class person
{
public:
	T1 name;
	T2 age;
	person(T1 name, T2 age);
};
template<class T1,class T2>
person<T1,T2>::person(T1 name,T2 age)
{
	this->name = name;
	this->age = age;
}
int main()
{
	return 0;
}
2.成员函数的类外实现
#include<iostream>
using namespace std;
#include<string>
template<class T1,class T2>
class person
{
public:
	T1 name;
	T2 age;
	person(T1 name,T2 age);
	void fun();
};
template<class T1, class T2>
person<T1, T2>::person(T1 name, T2 age)
{
	this->name = name;
	this->age = age;
}
template<class T1,class T2>
void person<T1, T2>::fun()
{
	cout << name << endl;
	cout << age << endl;
}
int main()
{
	person<string, int>p("埃里给", 18);
	p.fun();
	return 0;
}

11.类模板分文件编写

该程序包含一个头文件和一个源文件，头文件负责函数实现，源文件负责函数调用

.hpp后缀名：约定俗成的包含类模板的声明与实现。

1.头文件（person.hpp）
#pragma once
#include<iostream>
using namespace std;
#include<string>
template<class T1, class T2>
class person
{
public:
	person(T1 name, T2 age);
	void show();
	T1 name;
	T2 age;
};
template<class T1, class T2>
person<T1, T2>::person(T1 name, T2 age)
{
	this->name = name;
	this->age = age;
}
template<class T1, class T2>
void person<T1, T2>::show()
{
	cout << name << endl;
	cout << age << endl;
}
2.源文件
#include"person.hpp"
int main()
{
	person<string,int>p("埃里给", 18);
	p.show();
	return 0;
}
3.输出结果

12.类模板与友元

不想写了，想写的时候补上

【并发编程五】c++进程通信——共享内存（shared memmory)
junxuezheng的博客
11-14 9590
现代操作系统，对于内存管理，采⽤的是虚拟内存技术，也就是每个进程都有⾃⼰独⽴的虚拟内存空间，不同进程的虚拟内存映射到不同的物理内存中。所以，即使进程 A中 和 进程 B中 的虚拟地址是⼀样的，其实访问的是不同的物理内存地址，对于数据的增删查改互不影响。这样这个进程写⼊的东⻄，另外⼀个进程⻢上就能看到了，都不需要拷⻉来拷⻉去，传来传去，⼤⼤提⾼了进程间通信的速度。⽤了共享内存通信⽅式，带来新的问题，那就是如果多个进程同时修改同⼀个共享内存，很有可能就冲突了。那共享内存的⽅式，就很好的解决了这⼀问题。
13、共享内存实现数据通信
最新发布
天涯雨的博客
05-09 894
Linux下C编程；共享内存实现数据通信
共享内存
temper博客专栏
07-06 3万+
共享内存     共享内存是被多个进程共享的一部分物理内存。共享内存是进程间共享数据的一种最快的方法，一个进程向共享内存区域写入了数据，共享这个内存区域的所有进程就可以立刻看到其中的内容。原理图如下： 共享内存的实现分为两个步骤： 一、 创建共享内存，使用shmget函数。 二、 映射共享内存，将这段创建的共享内存映射到具体的进程空间去，使用shmat函数。 创建共享内存 int
共享内存——The Shared memory
赤子之心
10-26 1010
// share  the memory space // 出于多个进程之间通信考虑的 // 每个IPC的object 通过键，进程识别所用的object #include #include #include #include #include #define MEMSIZE 2048 int main() {  int shmid;  pid_t pid;  
macOS进程间通信的常用技术汇总
goldWave的博客
12-29 1360
macOS进程间通信的常用技术汇总。
Linux进程间通信——使用共享内存
tianmo2010的专栏
03-15 5966
下面将讲解进程间通信的另一种方式，使用共享内存。 一、什么是共享内存 顾名思义，共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc
进程间通信之共享内存C#源代码
10-24
3.共享内存（Shared Memory） 4.信号量（Semaphore） 5.消息队列（Message Queues） 6.远程过程调用（Remote Procedure Calls, RPC） 7.Mailslot 8.报文传输协议（Message Transfer Protocol, MTP） 9.串行端口...
java 共享内存ipc_进程间通信——IPC之共享内存
weixin_35943493的博客
02-16 2425
共享内存是三个IPC机制中的一个。它允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在进行的进程之间传递数据的一种非常有效的方式。大多数的共享内存的实现，都把由不同进程之间共享的内存安排为同一段物理内存.首先我们都知道我们执行的每一个程序，它看到的内存其实都是虚拟内存，虚拟内存需要进行页表的映射将进程地址映射到物理内存，具体处理大致如下面的图共享内存特点和优势当中共享内存的大致原理相信我...
13_信号量sem、共享内存shm
qq_56811048的博客
05-26 533
13_信号量sem、共享内存shm 文章目录13_信号量sem、共享内存shm1.信号量 sem2.共享内存shm 13_信号量sem、共享内存shm 1.信号量 sem 一般取正数值，值代表资源的数据，0,1二值信号量，3计数信号量 P 对信号量的值 原子减一 代表获取资源 信号量值=0时代表没有可用资源了，那么p操作阻塞 V 对信号量的值 原子加一 代表释放资源 临界资源：同一时刻只允许一个进程访问的资源 临界区：访问临界资源的代码段 同步 内核提供接口：semget，semctl，se.
基于ToLua的C#和Lua内存共享方案保姆级教程
学无止境的专栏
11-19 1520
ToLua C#和Lua内存共享方案
Linux共享内存的查看和删除
07-23
在使用共享内存的程序异常退出时，由于没有释放掉共享内存，在调试时会出现错误。您可以使用shell命令来查看与释放已经分配的共享内存，下面将详细说明如何进行查看和释放分配的共享内存的方法。
简单windows共享内存封装类
最快的脚步不是跨越，而是继续；最慢的步伐不是缓慢，而是徘徊！
09-21 8152
简单windows共享内存封装类
Mac下kernel_task进程cpu占用率久高不下解决记录
热门推荐
_Findway的博客
05-25 9万+
前几天一个同学说他的Macbook pro最近卡的不行，让我给他看看。 拿到他的Macbook后，果然卡的不行，打字都是一顿一顿的，简直比我的黑苹果还卡，我打开任务管理器查看了一下，发现一个kernel_task的进程cpu占用率竟然高达600%，很明显了，卡的原因就是这个了，我本以为找到原因，然后上网百度解决方案就行了，但是没想到这才刚是噩梦的开始。。。 我在百度上找了一圈，果然也有人遇到这个
共享内存（Shared Memory）介绍
wangrl的博客
02-22 3万+
共享内存是常用的进程间通信，两个进程可以直接共享访问同一块内存区域。
UNIX共享内存总结
nellson的专栏
03-20 1万+
    共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式。两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。因此，采用共
Linux IPC 共享内存基本用法
Life runs on code
05-08 1938
Linux IPC 常见的方式写 Linux Server 端程序，必然会涉及到进程间通信 IPC. 通信必然伴随着同步机制，下面是一些常见的通信与同步机制： 进程间通信：匿名管道，命名管道，消息队列，共享内存，Domain Socket, 本机 TCP Socket，文件 进程间同步：信号，信号量 线程间同步：条件变量，互斥量，读写锁，自旋锁，Barrier. 对于大部分的业务场景，本机 TCP
MAC OSX 进程间通信
miracle的专栏
11-18 1万+
Mac OS下的IPC方式种类很多，大约有下面几种。  1. Mach API  2. CFMessagePort  3. Distributed Objects (DO) NSDistributedNotificationCenter 4. Apple events  5. UNIX domain sockets  6. Internet sockets 或者 XPC(NSConne
linux共享内存设置
BrotherDong90的专栏
08-09 6212
最近频繁遇到共享内存的问题，这里总结一下一些设置： cat /proc/sys/kernel/shmmax cat /proc/sys/kernel/shmmni cat /proc/sys/kernel/shmall 临时修改这三个参数的值，通过echo或sysctl命令修改proc文件中的值，重启失效 echo 1073741824 > /proc/sys/kernel/shmm
C#实现进程间内存文件共享技术指南
通过共享内存，多个进程可以访问同一块内存区域，并且进行数据交换。 ### C#版本实现 在C#中，可以通过System.IO.MemoryMappedFiles命名空间来创建和使用内存映射文件。为了实现内存映射文件共享，通常需要以下...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值