C++第十二节课模板初阶和string引入

🕗 发布于 2024-09-23 18:59 c++ 开发语言 算法 vim 学习

一、函数模板

我们不需要写具体的函数，而是写这个函数的模板，编译器会根据模板生成对应的函数；

template<typename T>
template<class T>

两者的作用是等效的！

用模板完成的功能有时候也叫泛型编程；

如果我们要传递多种类型的参数：

template<typename T1,typename T2>
void Func(const T1& x, const T2& y)
{
cout << x << " " << y << endl;
}
int main()
{
Func(1, 2.2);
return 0;
}

可以通过定义多个模板参数来实现；

函数模板根据调用，自己退到模板参数的类型，实例化出对应的函数；

问题：模板参数可以用typename / class，那么可以用struct吗？

答案：不可以！规定不可以！

1、函数模板的实例化

模板参数的实例化分为两种：隐式实例化和显式实例化！

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

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);
// 下面这种编译不通过！
// Add(a1, d1);
}

这里只有一个模板参数，实例化的时候不知道该参数的类型为int还是double，会产生歧义！

有两种解决方法：

用户自己强制转化；
显示实例化

用于自己强制转化：

// 方法一：强制类型转换
cout << Add(a1, (int)d1) << endl;
cout << Add((double)a1, d1) << endl;

这里是根据实参传递的类型，推导T的类型

显示实例化：

// 方法二：显示实例化
cout << Add<int>(a1,d1) << endl;
cout << Add<double>(a1, d1) << endl;

这里是指定T的类型进行实例化；（会存在隐式类型的转换 --- 产生临时变量 --- 临时变量具有常属性 --- 因此参数需要加上const进行修饰！）

但是有一种情况必须使用显式实例化：

template<class T>
T* Alloc(int a)
{
return new T[a];
}

这与这个函数，我们如果要调用，必须使用显示实例化，因为参数的类型已经被指定，返回值T*不确定，此时应该指定T的类型；

double* p1 = Alloc<double>(a1);

只能通过显示实例化来调用！

2、模板参数的匹配原则

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

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 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函数
}

二、类模板

我们分析下下面的代码：

typedef int DataType;
class Stack
{
public:
 Stack(size_t capacity = 3)
 {
 _array = (DataType*)malloc(sizeof(DataType) * capacity);
 if (NULL == _array)
 {
 perror("malloc申请空间失败!!!");
 return;
 }
 _capacity = capacity;
 _size = 0;
 }
 void Push(DataType data)
 {
 // CheckCapacity();
 _array[_size] = data;
 _size++;
 }
 // 其他方法...
 ~Stack()
 {
 if (_array)
 {
 free(_array);
 _array = NULL;
 _capacity = 0;
 _size = 0;
 }
 }
private:
 DataType* _array;
 int _capacity;
 int _size;
};
void TestStack()
{
 Stack s;
 s.Push(1);
 s.Push(2);
}

如果我们改变一个栈中存放的数据类型;

typedef int DataType;

我们需要将int改为其他类型；

但是如果对于下面这种情况：

int main()
{
Stack s1;   // int
Stack s2;   // double
return 0;
}

栈s1要存放int类型；

栈s2要存放double类型；

如果不使用模板我们只能拷贝多份相同的代码用于存放不同的类型！

这时候我们可以将上面的代码改为模板形式的：

template<class T>
class Stack
{
public:
Stack(size_t capacity = 3)
{
/*_array = (T*)malloc(sizeof(T) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}*/
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}
void Push(const T& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};

类模板的实例化

此时如果我们需要创建对象，因为构造函数里面不一定有参数！因此我们不能隐式实例化的方式让编译器去猜，只能自己显示实例化！

因此我们这样子实例化：

int main()
{
Stack<int> s1();   //int
Stack<double> s2();  // double
Stack<char> s3();  //char

return 0;
}

注意点：类模板中函数的声明和定义与之前的不太一样：

template<class T>
class Stack
{
public:
Stack(size_t capacity = 3);
void Push(const T& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};

Stack(size_t capacity = 3)
{
/*_array = (T*)malloc(sizeof(T) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}*/
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}

如果我们直接在类外面对构造函数进行定义，此时编译器无法识别T！

template<class T>
class Stack
{
public:
Stack(size_t capacity = 3);
void Push(const T& data)
{
// CheckCapacity();
_array[_size] = data;
_size++;
}
// 其他方法...
~Stack()
{
if (_array)
{
free(_array);
_array = NULL;
_capacity = 0;
_size = 0;
}
}
private:
T* _array;
int _capacity;
int _size;
};

template<class T>
Stack<T>::Stack(size_t capacity = 3)
{
/*_array = (T*)malloc(sizeof(T) * capacity);
if (NULL == _array)
{
perror("malloc申请空间失败!!!");
return;
}*/
_array = new T[capacity];
_capacity = capacity;
_size = 0;
}

注意点：对于普通类还是，类型和类名是一样的！

例如：Date既是类型，也是类名！

但是类模板的类型和类名不相同！例如：

Vector类名
Vector<int>才是类型

template的作用范围可以认为是跟接下来的函数或者类的作用域（一个对应的花括号内）；

每个函数都需要写对应的模板参数！

三、string类

使用string类需要包含头文件：#include<string>

且string这个类位于标准库中，因此如我们可以采用下面两种形式：

int main()
{
string s1;
std::string s2;
return 0;
}

1、string的构造函数

int main()
{
string s1;   // 使用默认构造
string s2("张三");
string s3("hello");
string s4(10, 'a');    // 复制n个字符；
string s5(s2);   // 调用拷贝构造
return 0;
}

这些是较为常用的重载的构造函数；

分析上面这个拷贝构造函数：

拷贝一个对象从pos位置的len长度！------ 部分拷贝（len在这里为缺省值！pos是对应字符串的下标，与数组类似）

npos是什么？

这里的npos是一个公有的静态的成员变量，它的值为-1！

但实际上，它的值不等于-1，而是整形的最大值！

因为size_t 默认参数都是正数，此时是把一个负数传递给一个无符号数，会发生整型提升，提升后，len会变成size_t的最大值，且在32 位的系统中，size_t 的最大值是 4294967295，而在 64 位的系统中则最大为 18446744073709551615。

string s7(s3, 6);

因此，如果我们没有给第三个参数，默认的第三个参数的值非常大，也就是默认拷贝之后的所有内容！

接下来我们尝试调用第三种构造函数重载的形式：

int main()
{
string s1;   // 使用默认构造
string s2("张三");
string s3("hello world");
string s4(10, 'a');    // 复制n个字符；
string s5(s2);   // 调用拷贝构造

string s6(s3, 6, 5);
cout << s3 << endl;
cout << s6 << endl;
return 0;
}

并且可以发现string这个类重载了流输出，我们可以直接cout输出流；

并且，因为string类中重载了运算符，如果我们需要对两个字符串进行比较，我们可以采用下面的方法：

cout << (s1 == s2) << endl;
cout << (s1 < s2) << endl;

注意，流插入和流提取运算符的优先级比较高，因此这里我们需要加上括号！

假设我们需要将下面的字符串拆分为三部分：

string ur1("https://cplusplus.com/reference/string/string/string/");
string sub1(ur1, 0, 5);
string sub2(ur1, 8, 13);
string sub3(ur1, 22, ur1.size()-22);
//string sub3(ur1, 22);
cout << sub1 << endl;
cout << sub2 << endl;
cout << sub3 << endl;

如果没有缺省值，那么我们就得采用上面的方法，但是有了缺省值就非常方便；

分析下面的拷贝构造函数：

意思为：拷贝字符数组s的前n个字符进行初始化；

2、赋值运算符重载

对于赋值运算符，我们可以采用下面三种形式：

s1 = s2;
cout << s1 << endl;

s1 = "11111";
cout << s1 << endl;

s1 = '2';
cout << s1 << endl;

3、增删查改中的增

对于一个字符串，我们我们想向其中插入值：

int main()
{
string s1("hello");
// 尾插一个字符
s1.push_back(' ');
// 尾插一个字符串
s1.append("world");
cout << s1 << endl;
return 0;
}

使用push_back可以完成工作，但是还可以使用运算符重载“+=”：

int main()
{
string s1("hello");
// 尾插一个字符
//s1.push_back(' ');
 尾插一个字符串
//s1.append("world");
//使用运算符重载
s1 += " ";
s1 += "world";
cout << s1 << endl;
return 0;
}

也能达到目标！

问题：假设有一个正整数x，要求将x转为string对象，怎么实现？

int main()
{
size_t x;
cin >> x;
string xstr;
while (x)
{
size_t val = x % 10;
xstr += ('0' + val);
x /= 10;
}
cout << xstr << endl;
return 0;
}

但是这里得到的结果是反的，因此我们需要逆置，且考虑x为0的情况，具体情况我们下次再讲！

原文地址：https://blog.csdn.net/weixin_47702917/article/details/142317397

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

上一篇：力扣：用栈实现队列
下一篇：2012年408考研真题-数据结构

Python 函数用法与底层分析
也就是说，形式参数是在定义函数时使用的。传递可变对象的引用传递参数是可变对象（例如：列表、字典、自定义的其他可变对象等），实际传递的还是对象的引用。4：调用函数之前，必须要先定义函数，即先调用def创
阅读更多2024-09-23
webLogic反序列化漏洞CVE-2017-3506
webLogic反序列化漏洞CVE-2017-3506
阅读更多2024-09-23
相亲交易系统源码详解与开发指南
PHP和Laravel框架结合，构建高效、安全相亲交易平台。通过用户注册与登录、个人资料管理、匹配算法和消息通知等功能实现。关注安全性、性能优化和用户体验。
阅读更多2024-09-23
【二等奖论文】2024年华为杯研究生数学建模C题54页成品论文（后续会更新）
：摘要：随着国民经济发展和社会进步，基于电力电子技术的电能变换（得到迅速发展，尤其是新能源和信息通讯领域。
阅读更多2024-09-23
2024 年最新前端工程师 Vue3 框架详细教程（更新中）
vue 3 是 Vue.js 的最新版本，是一个用于构建用户界面的渐进式 JavaScript 框架。和 vue 2 相比，vue 3 引入了组合式 API，使开发者可以通过函数组织代码逻辑，适合处理
阅读更多2024-09-23
food facts食物营养成分数据集en.openfoodfacts.org.products
有个版本是2017年的，50M左右的，解开340M左右。最新的大约1G大小。
阅读更多2024-09-23
信息技术引领的智能化未来
随着信息技术的飞速发展，社会各个领域正在加速迈入智能化的新时代。信息技术的广泛应用，尤其是人工智能、大数据、物联网等前沿技术的创新与融合，正在从根本上改变着人们的生产和生活方式。本文将探讨信息技术在智
阅读更多2024-09-23
ubuntu安装StarQuant
【代码】ubuntu安装StarQuant。
阅读更多2024-09-23
UNet 眼底血管分割实战教程
✨🌈💫在医学影像分析领域，准确地分割眼底血管对于眼科疾病的诊断和治疗至关重要。本教程将详细介绍如何利用 UNet 进行眼底血管分割，包括云实例配置、数据集处理以及模型训练和测试。
阅读更多2024-09-23
适配器模式
将一个接口成客户希望的另一个接口，适配器模式使接口不兼容的那些类可以一起工作，适配器模式分为类结构型模式（继承）和对象结构型模式（组合）两种，前者（继承）类之间的耦合度比后者高，且要求程序员了解现有组
阅读更多2024-09-23

C++第十二节课 模板初阶和string引入