【C++知识点总结全系列 (07)】：模板与泛型编程详细总结与分析

还下着雨ZG

已于 2024-07-18 10:22:16 修改

阅读量720

点赞数 19

分类专栏： C++系列文章标签： c++ 开发语言

于 2024-07-18 10:17:32 首次发布

本文链接：https://blog.csdn.net/qq_42279379/article/details/140515401

版权

C++系列专栏收录该内容

8 篇文章 0 订阅

订阅专栏

模板与泛型编程

1、概述
2、模板函数
3、模板类
- (1)How（如何定义和使用模板类）
- (2)成员模板
4、模板实参和完美转发
5、动态内存分配
6、智能指针模板

1、概述

(1)What（什么是模板、泛型编程）

模板：

模板分为函数模板和类模板，其类内部的类型和函数的形参类型不具体指定，用一个虚拟的类型来代表，在具体使用的时候在具体化

泛型编程：

以一种独立于任何特定类型的方式编写代码，模板是泛型编程的基础

(2)Why

实现代码的重用

(3)Which

模板函数
模板类

(4)模板参数

A.What

模板参数是在 C++ 模板中使用的类型或非类型实体的占位符，分为类型模板参数和非类型模板参数

B.How

template <typename T> T calc(const T&, const T&); //模板的声明

注意：通常一个文件所有模板的声明放在文件的开始位置

C.模板参数的类型成员

T::value_type()：必须显式地告诉编译器该名字是一个类型，且只能使用关键字 typename（而非 class）

D.默认模板参数

与函数默认实参一样，对于一个模板参数，只有当它的右侧都有默认参时，它才可以有默认参数

在这里插入图片描述

2、模板函数

#include <sstream>
using namespace std; 
template <class T>//T 是类型模板参数
string tTostring(T t)
{
	std::ostringstream osstream; 
	osstream << t;
	return osstream.str(); 
}

template <typename T, typename U>//模板参数列表 
auto add(T t, U u){
	if constexpr (std::is_same<T, std::string>::value)
		return t + tTostring(u);
	if constexpr (std::is_same<U, std::string>::value)
		return tTostring(t) + u;
	if constexpr (std::is_arithmetic<T>::value && std::is_arithmetic<U>::value)
		return t + u;
}

3、模板类

(1)How（如何定义和使用模板类）

template <class T> 
class Blob {
public: 
typedef typename std::vector<T>::size_type size_type;
private:
std::vector<T> *data_; void check(size_type i, const std::string &msg) const; public:
Blob(){ data_ = new std::vector<T>();} 
Blob(std::initializer_list<T> il)
{ 
data_ = new std::vector<T>(il); 
} 
Blob(const Blob &blob) {//在一个类模板作用域内，可直接使用模板名，而不必指定模板参数
data_ = new std::vector<T>(*blob.getData());
// 也可 blob.data_,在类的成员函数内部，可直接访问同类的其他对象私有成员 }
~Blob()
{ 
delete data_;
}
std::vector<T> *getData() const
{
return data_;
} 
size_type size() const 
{
	return data_->size(); 
} 
bool empty() const 
{ 
	return data_->empty(); 
} 
void push_back(const T &t) 
{ 
	data_->push_back(t); 
} 
void push_back(T &&t)
{ 
 	data_->push_back(std::move(t)); 
} 
};
void main()
{
	Blob<double> blob; //实例化一个blob对象，用域处理double类型的数据
	...
}

(2)成员模板

本身是模板函数的成员函数，成员模板不能是虚函数

在这里插入图片描述

4、模板实参和完美转发

(1)模板实参推断

A.What（什么是模板实参推断）

在实例化模板函数或模板类的时候，进行模板实参推断

B.Which（有哪些常见的实参推断）

(a) 无法推断时必须显式地指定模板实参类型

template <typename T1, typename T2, typename T3>
T1 sum(T2, T3);
auto res = sum<long>(i, lng); //实例化：long sum(int, long)

(b) 尾置返回类型

template <typename It>
??? &func(It begin, It end)
{
	//TODO:业务逻辑处理
	return *begin; //返回序列中的引用
}
//为了避免不必要的歧义，一般定义成如下形式
auto &func(It begin, It end) -> decltype(*begin)
{
	//TODO:业务逻辑
	return *begin;
}
auto &str = func(vecStr.begin(),vecStr.end());
auto &i  = func(vecInt.begin(), vecInt.end());

(c ) STL中的标准类型转换

如下图所示，展示了如何将引用传递改为值传递：

常见的类型转换模板有如下：
(d) 实参推断和引用

如果一个函数参数的类型是 constT&，正常绑定规则告诉我们可以传递给它任意类型的实参—对象、临时变量、字面值常量

从左值引用推断模板参数：

从右值引用推断模板参数：
(e) 引用折叠和右值引用参数
- 将左值传递给右值参数引用时（且函数模板参数类型为 T&&)，编译器推断模板类型参数为实参的左值引用类型
下面程序中：T 的类型为 string&,参数类型为 string& &&，根据折叠原则，为 string &
```
template <class T> 
void show(T &&t){
	cout << t << endl;
}
string zs = "张三同学"; 
show(zs);//将左值引用传递给右值引用参数
```
- 我们不能直接定义一个引用的引用，但是，通过类型别名或模板类型参数可以间接定义引用的引用；此时会进行引用折叠
X& &、X& &&和X&& &都会折叠成类型X&
类型X&& &&折叠成X&&
- 总结：当模板函数的参数为T&&，则可以传递任意类型的实参给它
传递左值时：结果为int& && -> int &
传递右值时：结果为int&& && -> int &&

(3)完美转发

A.What（什么是完美转发）

某些函数将其一个或多个实参连同其类型不变地转发给其它函数，我们需要保证被转发实参的所有性质，这种保证转发实参所有性质的事情，我们称之为“完美转发”

B.How（如何进行完美转发）

常见的模板函数定义形式如下：

template <typename F, typename T1, typename T2>
auto flip(F f, T1 &&t1, T2 &&t2)
{
	return f(t1, t2);
}

假如存在函数func()如下：

int func(int& iVal01, int iVal02)
{
	return iVal01 + iVal02;
}
int main()
{
	int iVal = 10;
	auto res = flip(func, iVal, 30); //res为40
	return 1;
}

在上述例子中，T1为int& &&，折叠为int& t1，从而实现了完美转发

C. forward()和move()函数介绍

forward 可以保持给定实参的左值/右值属性

forward<T>(t); //使用方式，保持t的左值或右值属性

move函数将左值转换为右值

std::string str = "Hello, ThreeBody!";
std::string &&ref = std::move(str); //将左值强转为右值

(4)可变参数模板

A.What（什么是可变参数模板）

void show() // 终止条件 
{ 
	cout << endl; 
}
template <typename T, typename... Args> // Args 为模板参数包，表示 0 个或多个模板参数 
void show(const T &t, const Args &...args) // args 为函数参数包，表示 0 个或多个函数参数
{
	cout << t << " " << endl; 
	cout << sizeof...(Args) << endl; // 2 1 0 ;sizeof...运算符，返回包中参数的个数 cout << sizeof...(args) << endl; // 2 1 0
	show(args...); 
}
string zs = "张三"; 
double defict = 128.1; 
int year = 1981;
show(zs, defict, year);

B.包拓展

包拓展就是将它分解成构成元素

C.转发参数包

void show() // 终止条件
{
	cout << endl; 
}
template <typename T, typename... Args> // Args 为模板参数包，表示 0 个或多个模板参数 
void show(T &&t, Args &&...args) // args 为函数参数包，表示 0 个或多个函数参数
{
	cout << t << " " << endl; 
	cout << sizeof...(Args) << endl; // 2 1 0 ;sizeof...运算符，返回包中参数的个数 
	cout << sizeof...(args) << endl; // 2 1 0
	show(std::forward<Args>(args)...);
}

(5)模板特例化

A.What

对特定的模板参数提供定制实现；分为完全特化和偏特化

完全特化：所有模板参数都提供定制
偏特化：部分模板参数提供定制-只允许类模板偏特化，函数模板不允许

B.Why

为了针对特定类型或条件提供特殊的实现或行为。模板特例化可以在需要时覆盖通用模板，以针对某些特定情况做出额外的处理或提供定制化的实现

C.How

template <class T1, class T2, class T3> 
void display(T1 t1, T2 t2, T3 t3)
{
	cout << "通用模板版本 display" << endl; 
	cout << t1 << "," << t2 << "," << t3 << endl; 
}
template <> //完全特例化模板函数 display，函数模板不允许偏特例化 void display(double d, string str, int a)
{
	cout << "特化版本 display" << endl; 
	cout << a << "," << d << "," << str << endl;
}
int main(){
	string zs = "张三"; 
	double defict = 128.1; 
	int year = 1981;
	display(defict, zs, year); // 调用特例化版本的 
	display display(128.1, "李四", 1981); // 调用通用版本的 display 
	return 0;
}

5、动态内存分配

(1)动态内存分配概述

A. C++内存空间模型

在这里插入图片描述

B. What（什么是动态内存分配）

一种程序在 运行时 内存申请和释放的机制

C. Why（为什么要进行动态内存分配）

提升灵活性：静态内存分配需要编译器在程序编译时知道分配内存的大小，而动态内存分配机制则允许在程序运行时分配内存空间
便于内存管理：动态地创建和销毁对象，提供了灵活的内存管理方式
动态调整数据结构：如vector数据结构会在不足时重新分配内存空间

D. How（如何进行动态内存分配）

在C语言中，使用malloc和free来申请和释放堆栈中的内存空间
在C++中，使用new和delete来申请和释放堆栈中的内存空间

//使用C格式管理动态内存的分配和释放
const int SIZE = 1024;
int * ptrArrC = (int *)malloc(SIZE * sizeof(int));
free(ptrArrC);
//使用C++格式管理动态内存的分配和释放
int * ptrArrCPlus = new int[SIZE];
delete [] ptrArrCPlus;

(2)定位new运算符

A. What（什么是定位 new 运算符）

在指定的内存中创建对象

double dArr[1024];
 double ptrArr = new (&dArr[0]) double(100.0);

B. Why（定位 new 运算符的作用）

在预先分配的内存区域上创建对象，而不一定是在堆中开辟动态内存空间
特定的内存位置上创建对象，并根据需要提供参数来初始化对象
将对象放置在满足对齐要求的合适内存地址上，以满足底层系统的需求

C. How（如何使用定位 new 运算符）

在这里插入图片描述
需要注意的是：当管理的是类对象或结构体对象时，调用它的析构函数并不会释放动态内存空间

因此，正确的做法是调用delete运算符，该运算符会首先调用类对象的析构函数来销毁对象，然后回收动态内存
在这里插入图片描述

(3)重载new和delete

下图展示了重载new和delete运算符的方式，值得一提的是：当我们将下列运算符函数定义成类的成员函数时，它们都是隐式静态的（即默认是静态成员函数）

在这里插入图片描述
实例说明：

注意：上述代码在使用malloc存在一定问题，因为malloc分配的是字节数，所以在具体使用的时候应该乘以sizeof(obj)，即乘以所存对象占用的内存大小

6、智能指针模板

(1)概述

A.Why（C++为什么引入智能指针）

C++引入智能指针的根本原因就是解决手动管理动态内存所带来的问题，手动管理动态内存常见的问题如下：内存泄漏、悬挂指针、释放操作未定义等

内存泄漏问题：

当程序用光了它可用的动态内存空间，new就会报错

int *p = new int; //*p的值未定义
int *p2 = new int(); //*p的值初始化为0
//程序用光了它可用的堆内存空间
int *pn = new int; //此时将会抛出异常：std::bad_alloc
int *pn_noThrow = new (nothrow) int; //如果分配失败，将返回空指针nullptr

悬挂指针问题：

当使用delete释放了指向动态内存空间的指针p时，指针p就成为了一个悬挂指针（即在有的机器中，指针p还保存着曾经的内存地址）,因此在手动管理动态内存空间的时候，一定要在delete之后将对应指针置为nullptr或0

int *ptr = new int();
delete ptr;
ptr = nullptr; //避免悬挂指针从而引起的未定义定位（不可预知行为）

释放操作未定义问题：

释放一块非new分配的内存或将相同的指针释放多次，其行为是未定义的

B.What（什么是智能指针）

本质是一个封装了原始指针的模板类，在适当的时候（生命周期结束时）自动释放所管理的动态内存

C.Which（有哪些智能指针）

shared_ptr
weak_ptr
unique_ptr

智能指针	所有权	内存释放
shared_ptr	多个 std::shared_ptr 共享所有权	通过内部的引用计数机制，当引用计数为 0 时，自动释放内存
weak_ptr	不拥有所指向对象的所有权，它只是对 std::shared_ptr 的一种弱引用	-
unique_ptr	独占所有权	当 std::unique_ptr 超出其作用域时，自动释放所管理的内存

(2)How（如何使用智能指针）

C++中的智能指针，其本质都是类模板，因此在学习智能指针的时，我们可以像对待普通类对象一样使用智能指针对象。正是因为它的本质是类对象，因此使用智能指针的一般流程如下：创建智能指针对象和调用智能指针对象的方法

A.智能指针类的成员变量

shared_ptr智能指针：

成员数据	说明
T *ptr	存放实际数据的动态内存地址
int iCount	计数器，用于记录有多少个shared_ptr共享同一块内存空间
deleter	删除器，本质是一个函数对象，自定义资源释放的行为

unique_ptr智能指针：

成员数据	说明
T *ptr	存放实际数据的动态内存地址
deleter	删除器，本质是一个函数对象，自定义资源释放的行为

weak_ptr智能指针：

weak_ptr 是一种不控制所指向对象生存期的智能指针，它指向由一个 shared_ptr 管理的对象。将一个 weak_ptr 绑定到一个 shared_ptr 不会改变 sharedptr 的引用计数。一旦最后一个指向对象的 shared_ptr 被销毁，对象就会被释放。即使有 weakptr 指向对象，对象也还是会被释放，因此，weak_ptr 的名字抓住了这种智能指针“弱”共享对象

所以说weak_ptr可以说没有成员数据

B.智能指针类的成员函数

shared_ptr智能指针：

成员函数	说明
`constexpr shared_ptr() noexcept = default;`	默认的构造函数
`constexpr shared_ptr(nullptr_t) noexcept {}`	带空指针的构造函数
`explicit shared_ptr(T* ptr)`	传入指向堆内存的一般指针
`void swap(shared_ptr& _Other) noexcept`	交换两个智能指针所管理的内存
`void reset() noexcept`	释放资源
`remove_extent_t<_Ty>* get() const noexcept`	得到所管理动态内存的地址
`bool unique() const noexcept`	是否只有一个引用
`long use_count() const noexcept`	返回shared_ptr对象的引用数

在这里插入图片描述

unique_ptr智能指针：

成员函数	说明
`constexpr unique_ptr() noexcept`	默认的构造函数
`constexpr unique_ptr(nullptr_t) noexcept`	带空指针的构造函数
`explicit unique_ptr(pointer _Ptr) noexcept`	传入指向堆内存的一般指针
`void swap(shared_ptr& _Right ) noexcept`	交换两个智能指针所管理的内存
`_Dx& get_deleter() noexcept`	得到删除器对象
`pointer release() noexcept`	释放所管理动态内存的地址
`void reset(pointer _Ptr = nullptr) noexcept`	如果reset函数带有参数，则会释放当前指向的对象，并将unique_ptr指向新的对象

在这里插入图片描述

weak_ptr智能指针：

成员函数	说明
`constexpr weak_ptr() noexcept = default;`	默认的构造函数
`weak_ptr(const weak_ptr& _Other) noexcept`	拷贝构造函数
`weak_ptr(const shared_ptr<_Ty2>& _Other) noexcept`	带shared_ptr对象的构造函数
`void swap(weak_ptr& _Other) noexcept`	交换两个智能指针所管理的内存
`void reset() noexcept`	释放资源
`bool expired() const noexcept`	use_count()为0时返回true
`shared_ptr<_Ty> lock() const noexcept`	转为shared_ptr对象
`long use_count() const noexcept`	返回对应shared_ptr对象的引用数

在这里插入图片描述

(3)使用智能指针需要注意的事项

不要混合使用常规指针和智能指针

使用内置指针访问智能指针管理的对象是危险的，无法知道对象何时被销毁
不要使用get()函数初始化另一个智能指针或为另一个智能指针赋值
不 deleteget()返回的指针
不使用相同的内存指针初始化（reset）多个智能指针
如果智能指针所管理的内存不是 new 分配的内存，要传递一个删除器

================================================================================

还下着雨ZG

关注

19
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
【C++知识点总结全系列 (07)】：模板与泛型编程详细总结与分析

1.概述：模板和泛型编程的概念、作用，模板的种类（模板函数、模板类）；2.模板函数；3.模板类：概念、作用、模板类；4.模板实参推断：左值引用和右值引用、完美转发；5.动态内存分配：new和delete，定位new和delete、动态数组；6.智能指针：直接内存管理、shared_ptr、unique_ptr、weak_ptr、智能指针使用和异常、智能指针的使用规范；
复制链接

扫一扫

专栏目录