C++的初阶模板和STL

🕗 发布于 2024-09-20 04:47 c++ 开发语言 算法 数据结构 汇编

C++的初阶模板和STL

在这里插入图片描述

回顾之前的内存管理，我们还要补充一个概念：内存池

也就是定位new会用到的场景，内存池只会去开辟空间。

申请内存也就是去找堆，一个程序中会有很多地方要去找堆，这样子效率会很低下，为了提高程序运行的效率，我们需要建立内存池，多去储存一些内存。

第二种理解方式：因为距离太远了，所需要的成本太高了，需要建立内存池。

在这里插入图片描述

这里再来打个比方，堆相当于妈妈，掌管着财政，家里有你，爸爸，弟弟，妹妹，以前你还没有上大学，用到钱的地方不多，可以直接问妈妈要钱，但是随着你上了大学，发现喝水吃饭洗澡没有一个地方不需要用钱，于是向妈妈要钱的次数变多了，爸爸有工作，需要用钱的地方不多，弟弟妹妹需求也不是很大。所以妈妈直接给了你一笔生活费，从那里面去取着用，这就相当于内存池

在这里插入图片描述

内存管理我们需要注意两个点：

1.不要忘记释放

2.不要错配

不要忘记释放好理解的，我们学过malloc和free都懂，动态开辟内存空间，需要程序员手动释放空间；

不要错配来看一个例子：

#include<iostream>
using namespace std;

class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
delete _p;
}
private:
int _a;
int* _p = new int;
};

int main()
{
///*A* p2 = (A*)operator new(sizeof(A));
//new(p2)A(10);
//
//p2->~A();
//operator delete(p2);*/
//
//// 1、不要忘记释放
//// 2、不要交错使用
//// 
////A* p1 = (A*)operator new(sizeof(A));
////delete p1;
//
///*A* p1 = new A;
//delete p1;*/
//  
}

在这里插入图片描述

不要用new ,delect的时候，想着用malloc,free混着用

模板初阶

我们先来看一段代码：

如何实现一个通用的交换函数呢？

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;
}

C语言，函数名必须不同，C++支持函数的重载，函数名可以相同，支持参数不同的，但是上面这三个函数逻辑结构类似，有什么办法简化呢？

答案是模板

模板像做月饼的模子一样，可以工业化生产。

使用函数重载虽然可以实现，但是有一下几个不好的地方：

重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数
代码的可维护性比较低，一个出错可能所有的重载均出错泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

函数模板

函数模板概念

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

函数模板格式

template<typename T1, typename T2,…,typename Tn>

返回值类型函数名(参数列表){}

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

注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替 class)

实现例子如下：

#include <iostream>
using namespace std;
template<class T>
void Swap(T& left, T& right)//注意要大写，否则会跟库里面的函数冲突
{
T temp = left;
left = right;
right = temp;
}
int main()
{
int x = 0;
int y = 8;
Swap(x, y);
double m = 1.0;
double n = 2.0;
Swap(m, n);
}

函数模板的原理

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

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

其实模板也就是让编译器去当牛马，函数模板类似于函数的调用

template<class T1, class T2>      // 类型
void Swap(T1& left, T2& right)   // 对象

函数模板的实例化

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

隐式实例化：让编译器根据实参推演模板参数的实际类型

template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
int a1 = 10, a2 = 20;
double d1 = 10.0, d2 = 20.0;
Add(a1, a2);
Add(d1, d2);
/*
该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型
通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有
一个T，
编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要
背黑锅
Add(a1, d1);
*/
// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
Add(a, (int)d);
return 0;
}

需要注意的是打印结果会有所出入：

测试代码：

template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
//int x = 0;
//int y = 8;
//Swap(x, y);
//double m = 1.0;
//double n = 2.0;
//Swap(m, n);
int a1 = 10;
int a2 = 20;
double a3 = 10.1;
double a4 = 20.2;
cout << Add(a1, (int)a3) << endl;
cout << Add((double)a1, a3) << endl;

}

在这里插入图片描述

显式实例化：在函数名后的<>中指定模板参数的实际类型

int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}

显示实例化的应用场景：

template <class T>
    T*Func(size_t n)
{
return new T[n];
}
Func<int>(10);
//这里形参没有带模板参数，需要显示实例化，因为没有办法推导

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

模板参数的匹配原则

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

// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非模板函数匹配，编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
}

2.对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数，那么将选择模板

// 专门处理int的加法函数
int Add(int left, int right)
{
return left + right;
}
// 通用加法函数
template<class T1, class T2>
T1 Add(T1 left, T2 right)
{
return left + right;
}
void Test()
{
Add(1, 2); // 与非函数模板类型完全匹配，不需要函数模板实例化
Add(1, 2.0); // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的
//Add函数
}

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

类模板

类模板的定义格式

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

拿栈来举例：

#include<iostream>
using namespace std;
// 类模版
template<typename T>
class Stack
{
public:
Stack(size_t capacity = 4)
{
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
void Push(const T& data);
private:
T* _array;
size_t _capacity;
size_t _size;
};
// 模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误
template<class T>
void Stack<T>::Push(const T& data)
{
// 扩容
_array[_size] = data;
++_size;
}
int main()
{
// 实例化生成对应的类，这里是两个不同的类型
Stack<int> st1; // int
Stack<double> st2; // double
return 0;
}

类模板的实例化

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

// Stack是类名，Stack<int>才是类型
Stack<int> st1; // int
Stack<double> st2; // double

string类

为什么学习string类？

C语言中的字符串

C语言中，字符串是以’\0’结尾的一些字符的集合，为了操作方便，C标准库中提供了一些str系列的库函数，但是这些库函数与字符串是分离开的，不太符合OOP的思想，而且底层空间需要用户自己管理，稍不留神可能还会越界访问。

标准库中的string类

string类(了解)

在使用string类时，必须包含#include头文件以及using namespace std;

string类的常用接口说明（注意下面我只讲解最常用的接口）

string类对象的常见构造

在这里插入图片描述

调试代码如下：

int main()
{
string s1;
string s2("1111122222");
string s3("1111111111", 3);//拷贝前3个数据
string s4(100, 'x');
string s5(s2, 4, 3);//从第四个开始打印三个数
string s6(s2, 4);//没有限制，到字符串结尾
string s7(s2, 4, 20);//超过长度，依旧是拷贝到字符串结尾

cout << s1 << endl;
cout << s2 << endl;
cout << s3 << endl;
cout << s4 << endl;
cout << s5 << endl;
cout << s6 << endl;
cout << s7 << endl;
}

打印结果：

在这里插入图片描述

小小补充：

string的访问

代码：

class string
{
public:
char& operator[] (size_t pos)
{
assert(pos < _size);
return _str[pos];
}
private:
char* _str;
size_t _size;
size_t _capacity;
};
int main()
{
//s2.operator[](0) = 'x';
s2[0] = 'x';
s2[5] = 'x';
cout << s2 << endl;

for (size_t i = 0; i < s2.size(); i++)
{
s2[i]++;
}
cout << s2 << endl;
//s2[30];

return 0;
}

重载的底层在于断言，这有效防止越界的问题

访问可以做到像数组一样的改变，主要是因为引用，一般的传值返回是传的是拷贝

代码：

class string
{
public:
char& operator[] (size_t pos)
{
assert(pos < _size);
return _str[pos];
}
private:
char* _str;
size_t _size;
size_t _capacity;
};
int main()
{
//s2.operator[](0) = 'x';
s2[0] = 'x';
s2[5] = 'x';
cout << s2 << endl;

for (size_t i = 0; i < s2.size(); i++)
{
s2[i]++;
}
cout << s2 << endl;
//s2[30];

return 0;
}

重载的底层在于断言，这有效防止越界的问题

访问可以做到像数组一样的改变，主要是因为引用，一般的传值返回是传的是拷贝

模板的学习一定要借助文档，看之前先猜测一下，然后和底下的英文注释做对比

原文地址：https://blog.csdn.net/Mr_Xuhhh/article/details/142370731

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Python快速入门 —— 第四节：数据库操作
下一篇：halcon中的放射变换

Maven(29)如何使用Maven进行依赖传递？
Maven的依赖传递性是指当一个库被添加到项目中时，该库所依赖的其他库也会被自动引入。这种机制简化了依赖管理，但也可能导致依赖冲突。
阅读更多2024-11-10
Linux的基本指令(二)
mv命令是move的缩写，可以用来移动文件或者将文件改名语法：mv 源文件或目录(参数一) 源文件或目录(参数二)1.当俩个参数都是文件时，如果参数二不存在则会执行改名字操作(改名字既覆盖)，如果参数
阅读更多2024-11-10
【嵌入式开发——ARM】2ARM汇编指令
ARM架构汇编指令
阅读更多2024-11-10
华夏风物 3.2.0 | 中国风物志，记录各地特产、美食、风景，旅游吃货必备
通过App上的推荐，用户可以发现并品尝到地道的地方美食。迅雷网盘：https://pan.xunlei.com/s/VOBFyGwdYAs0FhyaOJ3AP40DA1?百度网盘：https://pa
阅读更多2024-11-10
mapreduce 将数据清洗后保存到 hbase
mapreduce 将数据清洗后保存到 hbase
阅读更多2024-11-10
【优选算法 — 滑动窗口】长度最小的子数组 & 无重复字符的最长子串
长度最小的子数组无重复字符的最长数组
阅读更多2024-11-10
鸿蒙next版开发：ArkTS组件通用属性（前景色设置）
通过本文的介绍，你应该对HarmonyOS 5.0中ArkTS组件的前景色设置有了基本的了解。前景色设置是UI开发中的重要工具，合理利用这些属性可以使你的应用界面更加美观和实用。希望本文能够帮助你在开
阅读更多2024-11-10
JAVA 多线程之ForkJoin
Fork/Join 框架是jdk7提供的一个用于并行执行任务的框架，是一个把大任务分成若干小任务，最终汇总每个小任务结果，最终得到大任务计算结果的框架。首先，我们需要一个fork类，来把大任务拆分成子
阅读更多2024-11-10
【CSS】清除浮动（父元素塌陷）
在CSS布局中，“清除浮动”通常指的是消除由浮动元素引起的某些副作用，特别是当这些浮动元素影响到后续元素或者父元素的高度计算时。浮动元素会使它们脱离正常的文档流，这可能导致一些意料之外的效果，比如父元
阅读更多2024-11-10
二叉树-堆
二叉树-堆
阅读更多2024-11-10

C++的初阶模板和STL