c++模板初识，STL简介

🕗 发布于 2024-07-23 21:29 c++ 开发语言

前言

本篇博客讲解一下c++的类和对象，看这个之前请先看：C++内存管理-CSDN博客

💓 个人主页：普通young man-CSDN博客

⏩ 文章专栏：C++_普通young man的博客-CSDN博客

⏩ 本人giee:普通小青年 (pu-tong-young-man) - Gitee.com

若有问题评论区见📝

🎉欢迎大家点赞👍收藏⭐文章

泛型编程

函数模板

简单的说一下模板的概念，你们应该听过活字印刷吧，c++的模板和这个概念差不多，就是说，你一种函数或者类，你给他一个模板，他就可以传任何类型的变量，这个也叫泛型编程。

泛型编程

这里实现一下能传不同类型参数的Swap(交换函数)

void Swap(int& x,int& y) {
int tmp = x;
x = y;
y = tmp;
}
void Swap(double& x, double& y) {
double tmp = x;
x = y;
y = tmp;
}

void Swap(char& x, char& y) {
char tmp = x;
x = y;
y = tmp;
}

int main() {
int p1 = 1, p2 = 2;
double a1 = 1.0, a2 = 2.0;
char b1 = 'x', b2 = 'y';

Swap(p1, p2);
Swap(a1, a2);
Swap(b1, b2);


cout << p1 << ' ' << p2 << endl;
cout << a1 << ' ' << a2 << endl;
cout << b1 << ' ' << b2 << endl;

}

这里其实是函数重载实现的这些，但是函数重载是有缺点的：

第一：每需要一个新的类型，就要新写一个函数。

第二：如果一个函数报错，其他函数也用不了。

那有什么方法可以帮助我们解决这个问题？

那现在我们就可以给一个摸具，你想他是什么类型，他就是什么类型，比如：

如果在C++中，也能够存在这样一个模具，通过给这个模具中填充不同材料(类型)，来获得不同材料的铸件(即生成具体类型的代码），那将会节省许多头发。巧的是前人早已将树栽好，我们只需在此乘凉。

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

函数模板

函数的概念

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

函数模板格式

template<class T,class T...>
返回类型 函数名(参数列表) {

}

把刚才的Swap用模板实现一下

template <class T>
void Swap(T& x,T& y) {
T tmp = x;
x = y;
y = tmp;
}

int main() {
int x = 10,y = 20;
double a = 10.2, b = 20.1;
Swap(a, b);
Swap(x,y);
cout << x << ' ' << y << endl;
cout << a <<' '<< b << endl;
}

你会发现他什么类型都可以传，这边我只传了两种类型

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

函数模板的原理

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

编译器需要根据传入的数据来推演出对应的函数类型，编译器需要根据传入的实参类型来推演生成对应类型的函数。

这边我举一个错误的例子：

这边我直接传入数字，你会发现报错了，这是为什么，其实这是因为编译器他是通过传的实际参数来推演你的类型，但是你的实参就是一个数字，编译器也不知道你要传的是什么类型，所以他报了个错误

函数模板的实例化

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

隐式实例化

隐式实例化就是让编译器自己推演出需要的类型

template<class T>
T Add(const T& x,const T& y) {
return x + y;
}

int main() {
int a = 10, b = 20;
double c = 10.1, d = 20.2;
cout << Add(a, b) << endl;;
cout << Add(c, d) << endl;;

}

当a,b,c,d被传到模板时候他就会推演出需要的类型，来满足要求

假如你这样写

这边我第一个参数是int第二个参数是double，编译器就无法推演出你到底是用int还是double，这里有两种方法，第一种是显示实例化，第二种就是增加模板参数(下面我会讲)

多参数模板

多参数模板就是可以多个实参类型传参数，他是根据你第一个参数来决定你后面参数的类型

template<class T1,class T2>
T1 Add(const T1& x,const T2& y) {
return x + y;
}

int main() {
int a = 10, b = 20;
double c = 10.1, d = 20.5;
/*cout << Add<int>(a, d) << endl;
cout << Add<double>(c, b) << endl;*/
cout << Add(b,d) << endl;
cout << Add(c, b) << endl;


}

显示实例化

显示实例化就是直接给编译器说，这个类型是什么，然后你传参数是传的不是一个类型，这里就会走隐式类型转换

这里我用<类型>来告诉编译器这里是int类型，即便我传的是double类型，他会通过一个隐式类型转换把他转换成int类型,这个就是显示实例化。

模板参数的匹配原则

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

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

如果一个你想计算Add,你调用了这个函数，他会去调用模板函数还是非模板函数，这里调用的就是非模板函数，可以看一下汇编

可以发现模板函数和非模板函数的地址是不一样的，其实也可以发现编译器很聪明，知道有现成的直接用的道理

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

这个就是说函数模板需要<int>或者多参数才能走这个隐式类型转换，但是函数不需要，它可以直接转换

类模板

类模板的定义格式

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

这边我直接用类模板写一个栈，你就知道他有多爽多方方便了

template <class T>
class Stack
{
public:
Stack(int capacity = 4){
_arr = new T[capacity];
_size = 0;
_capacity = capacity;
}
void Push(const T& data) {
if (_size == _capacity)
{
int capacity_s = _capacity * 2;
T* tmp = new T[capacity_s];
memcpy(tmp, _arr, sizeof(capacity_s));
_arr = tmp;
_capacity = capacity_s;
}
_arr[_size++] = data;
}

private:
T* _arr;
int _size;
int _capacity;
};


int main() {
//实例化模板
Stack<int> s1;//int
Stack<double> s2;//double
s1.Push(1);
s1.Push(2);

s2.Push(2.15);
s2.Push(2.16);



}

如果是以前C语言是不是得写几个函数才能传不同类型，这里自己就可以实例化不同类型得类。

类模板的实例化

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

好了今天得博客就到这里了，谢谢大家得观看

STL简介

STL（Standard Template Library，标准模板库）是C++标准库的一个重要组成部分，它提供了一系列可重用的组件，包括容器、算法、迭代器和函数对象，用于高效地处理数据结构和算法问题。STL的设计原则是将数据和操作数据的算法分离，这使得它可以非常灵活地应用于各种不同的场景。

容器(Container)

容器是STL中用于存储数据的对象。它们可以分为以下几类：

序列容器：如 vector、list 和 deque，这些容器按顺序存储元素，支持快速随机访问（对于 vector 和 deque），或高效的插入和删除操作（对于 list）。
关联容器：如 set、map、multiset 和 multimap，这些容器基于红黑树实现，元素根据键值排序，并且支持对数时间复杂度的查找、插入和删除操作。
容器适配器：如 stack、queue 和 priority_queue，它们是基于其他容器构建的，提供特定的接口，如后进先出（LIFO）或先进先出（FIFO）的行为。

算法(Algorithm)

STL算法是一系列通用函数，可以应用于任何符合一定要求的序列上。这些算法包括：

修改序列：如 sort、reverse 和 fill。
查询序列：如 find、count 和 equal_range。
变换序列：如 transform 和 copy。
归并序列：如 merge 和 inplace_merge。
数值算法：如 accumulate 和 inner_product。

迭代器(Iterator)

迭代器是一种可以遍历容器元素的对象，类似于指针，但功能更强大，能够处理不同类型容器的内部细节。迭代器提供了访问容器元素的一致接口，使得算法可以独立于容器的类型工作。

函数对象(Function Object)

函数对象，也被称为仿函数，是一种行为类似函数的类，通过重载括号运算符 operator() 来实现。它们可以被用作算法的参数，用于自定义比较、操作等逻辑。

STL的设计强调了泛型编程，这意味着它的组件可以在不知道具体数据类型的情况下工作，从而提高了代码的重用性和灵活性。此外，STL还提供了丰富的异常安全性和性能优化特性，使其成为现代C++编程不可或缺的一部分。

总的来说，STL提供了一套经过优化、高度可读且易于使用的工具，极大地简化了C++程序的开发过程，减少了常见的编程错误，同时保持了高性能。

STL学习的阶段

简单总结一下：学习STL的三个境界：能用，明理，能扩展 。