桌面端编程之通过C++的标准模板库代码快速提高编程能力

Posted 2023-04-04 audyxiao001

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了桌面端编程之通过C++的标准模板库代码快速提高编程能力相关的知识，希望对你有一定的参考价值。

如同练习书法一样，要提高自己的书法技艺，首先要临帖。类似地，要快速地提高自己的编程能力，写出标准规范、质量高的代码，可借鉴C++的标准模板库代码，即STL（StandardTemplate Library）。先仔细观摩和理解STL中的代码，然后仿照其风格编写代码，这样就能够快速地提高自己的编程能力。那么，如何下载和查看STL源码呢？有如下的三种方式：

1. 通过网络下载的标准库及文档查看源码

SGI版本的STL源码一般来说可读性比较好，读者可以首选该版本的STL进行学习。SGI版本的STL源码可以去GitHub网站上进行下载，下载的网址为：https://github.com/steveLauwh/SGI-STL。

此外，读者也可以从glibc网站下载STL源码进行学习，具体网址为：http://ftp.gnu.org/gnu/glibc。

2. 通过已经出版的关于STL的书籍查阅STL源码

市面上有一些讲解STL源码的常用教材，读者也可以通过这些教材进行STL源码的学习。如下两本常用教材可供读者参考：侯捷老师编写的《STL源码剖析》、Ivor Horton编著、郭小虎等翻译的《C++标准模板库编程实战》。

3. 通过Visual Studio自带的STL源码库查看

可以通过Visual Studio安装包中自带的标准模板库来查看STL。例如，如果你安装的是Visual Studio 2010可以在Microsoft Visual Studio10.0\\VC\\crt\\src路径下找到Visual Studio自带的STL源码库。读者可以学习此源码库，提高自己的编程能力。

为软件编写界面非常重要，如果想了解通过C++如何编写界面，敬请关注本公众号的下一篇文章《桌面端编程之与C++配套的界面编程工具》。

关于人工智能中编程能力和技能训练的更多介绍，可以购买《人工智能怎么学》进一步阅读。

图书购买方式

京东：https://item.jd.com/13395339.html

当当：http://product.dangdang.com/29469230.html

天猫：https://detail.tmall.com/item_o.htm?id=687374654836

为了让图书惠及更多的读者，为更多想学习人工智能的人提供帮助，经过向出版社申请，对图书《人工智能怎么学》的部分内容进行改编和连载。图书《人工智能怎么学》的全部内容包含了初级入门、中阶提高以及高级进阶三个级别的内容。连载的内容主要是初级入门级别，适合想对人工智能进行快速和高效入门的读者，对于已有一定的人工智能学习基础，希望进一步进阶或提高的读者，则需要购买图书《人工智能怎么学》，学习中阶提高以及高级进阶的内容。此外，对于学习人工智能感兴趣的读者，也可以加入知识星球《人工智能怎么学》，知识星球是一个构建学习社群的平台，通过加入《人工智能怎么学》的社群，你将获得更多的学习资料和课程信息。

与作者互动和了解更多信息

想跟作者一起学习人工智能和互动，你可以加入如下社群：

知识星球：https://t.zsxq.com/0aLkVg0os

QQ群：600587177

想了解更多关于人工智能学习及实践的内容，请关注如下媒体：

官方网站：https://bigdatamininglab.github.io

官方微信公众号：人工智能怎么学(可扫描下方二维码或者微信搜索“人工智能怎么学”添加关注)

CSDN：https://blog.csdn.net/audyxiao001

参考文献

Robert C. Martin. 代码整洁之道（第2版）[M]. 韩磊, 译. 北京: 中国工信出版集团, 人民邮电出版社, 2020.

Herb Sutter, Andrei Alexandrescu. C++编程规范：101条规则、准则与最佳实践[M]. 刘基诚, 译. 北京: 人民邮电出版社, 2016.

杨冠宝. 阿里巴巴Java开发手册[M]. 北京: 电子工业出版社, 2020.

James Gosling et al. The Java Language Specification：Java SE 8 Edition[M]. Upper Saddle River: Addison-Wesley, 2014.

老九君. C++的发展简史[EB/OL]. https://www.cnblogs.com/ljxt/p/11636342.html , 2019-10-08.

翁惠玉. C++程序设计：思想与方法（第2版）[M]. 北京: 人民邮电出版社, 2012.

谭浩强. C++程序设计（第3版）[M]. 北京: 清华大学出版社, 2015.

Siddhartha Rao. Sams Teach Yourself C++ in One Hour a Day(Eighth Edition) [M]. Boston: Pearson, 2017.

Bjarne Stroustrup. Programming：Principles andPractice Using C++ (Second Edition) [M]. Crawfordsville: Pearson, 2014.

Bjarne Stroustrup.C++语言设计和演化[M]. 裘宗燕, 译. 北京: 人民邮电出版社, 2020.

Stephen Prata. C++Primer Plus（中文第6版）[M]. 张海龙等, 译. 北京: 人民邮电出版社, 2020.

Stanley B.Lippman, Josée Lajoie,Barbara E. Moo. C++ Primer（中文第5版）[M]. 王刚等, 译. 北京: 电子工业出版社, 2013.

Stanley B. Lippman.Essential C++（中文版）[M]. 侯捷, 译. 北京: 电子工业出版社, 2013.

侯捷. STL源码解析 [M]. 武汉: 华中科技大学出版社, 2015.

Ivor Horton. C++标准模板库编程实战 [M]. 郭小虎等, 译. 北京: 清华大学出版社, 2017.

Brian W.Kernighan, Rob Pike. 程序设计实践 [M]. 裘宗燕, 译. 北京: 机械工业出版社, 2003.

Bruce Eckel. C++编程思想（两卷合订本）[M]. 刘宗田等, 译. 北京: 机械工业出版社, 2011.

Scott Meyers.Effective C++：改善程序与设计的55个具体做法（第3版）[M]. 侯捷, 译. 北京: 电子工业出版社, 2011.

Scott Meyers. More Effective C++：35个改善编程与设计的有效方法[M]. 侯捷, 译. 北京: 电子工业出版社, 2020.

Scott Meyers. Effective STL：50条有效使用STL的经验[M]. 潘爱民等, 译. 北京: 电子工业出版社, 2013.

陆文周. Qt 5开发及实例（第4版）[M]. 北京: 电子工业出版社, 2019.

王维波. Qt 5.9 C++开发指南 [M]. 北京: 人民邮电出版社, 2018.

冯振, 郭延宁, 吕跃勇. OpenCV 4快速入门 [M]. 北京: 电子工业出版社, 2020.

ghscarecrow.Java的发展历程[EB/OL]. https://blog.csdn.net/ghscarecrow/article/details/82318636, 2018-09-02.

JMCui.Java的发展历程[EB/OL]. https://www.cnblogs.com/jmcui/p/11796303.html, 2019-11-07.

明日科技. Java从入门到精通（第5版）[M]. 北京: 清华大学出版社, 2019.

Kathy Sierra, BertBates. Head First Java (Second Edition) [M]. Sebastopol: O’Reilly, 2005.

Bruce Eckel. Java编程思想（第4版）[M]. 陈昊鹏, 译. 北京: 机械工业出版社, 2007.

Cay S. Horstmann.Java核心技术卷I：基础知识（第11版）[M]. 林琪等, 译. 北京: 机械工业出版社, 2019.

Cay S. Horstmann.Java核心技术卷Ⅱ：高级特性（第11版）[M]. 陈昊鹏, 译. 北京: 机械工业出版社, 2020.

Joshua Bloch. EffectiveJava（中文第3版）[M]. 俞黎敏, 译. 北京: 机械工业出版社, 2019.

周志明. 深入理解Java虚拟机：JVM高级特性与最佳实践（第3版）[M]. 北京: 机械工业出版社, 2019.

Brian Goetz. Java并发编程实战 [M]. 童云兰译. 北京: 机械工业出版社, 2012.

Kamalmeet Singh.Java设计模式及实践 [M]. 张小坤等, 译. 北京: 机械工业出版社, 2013.

明日科技. Java Web从入门到精通（第3版）[M]. 北京: 清华大学出版社, 2019.

未来科技.HTML5+CSS3+javascript从入门到精通[M]. 北京: 中国水利水电出版社, 2017.

Elisabeth Robson,Eric Freeman. Head First HTML与CSS（第2版）[M]. 徐阳等, 译. 北京: 中国电力出版社, 2013.

Adam Freeman.HTML5权威指南 [M]. 谢廷晟等, 译. 北京: 人民邮电出版社, 2014.

Eric A. Meyer, EstelleWeyl . CSS权威指南（第4版）[M]. 安道, 译. 北京: 中国电力出版社, 2019.

David Flanagan.JavaScript权威指南（第7版）[M]. 李松峰, 译. 北京: 机械工业出版社, 2021.

许令波. 深入分析Java Web技术内幕（修订版）[M]. 北京: 电子工业出版社, 2014.

Nicholas S.Williams. Java Web高级编程 [M]. 王肖峰, 译. 北京: 清华大学出版社, 2015.

孙卫琴. Tomcat与Java Web开发技术详解（第3版）[M]. 北京: 电子工业出版社, 2019.

郭霖. 第一行代码android（第3版）[M]. 北京: 人民邮电出版社, 2020.

欧阳燊. Android Studio开发实战：从零基础到App上线（第2版）[M]. 北京: 清华大学出版社, 2018.

Dmitry Jemerov, SvetlanaIsakova. Kotlin实战 [M]. 覃宇等, 译. 北京: 电子工业出版社, 2017.

Kristin Marsicano, Brian Gardner,Bill Phillips, Chris Stewart. Android编程权威指南（第4版）[M]. 王明发, 译. 北京: 中国工信出版集团, 人民邮电出版社, 2021.

刘望舒. Android进阶之光（第2版）[M]. 北京: 电子工业出版社, 2021.

邓凡平. 深入理解Android: Java虚拟机ART [M]. 北京: 机械工业出版社, 2019.

任玉刚. Android开发艺术探索[M]. 北京: 电子工业出版社, 2015.

林学森. 深入理解Android内核设计思想（上、下册）（第2版）[M]. 北京: 人民邮电出版社, 2017.

何红辉, 关爱民. Android 源码设计模式解析与实战（第2版）[M]. 北京: 人民邮电出版社, 2017.

Christian Keur,Aaron Hillegass. ios编程（第6版）[M]. 王风全, 译. 武汉: 华中科技大学出版社, 2019.

张益珲. Swift 4从零到精通iOS开发[M]. 北京: 清华大学出版社, 2019.

Aaron Hillegass,Mikey Ward. Objective-C编程（第2版）[M]. 王蕾等, 译. 武汉: 华中科技大学出版社, 2015.

Matthew Mathias,John Gallagher. Swift编程权威指南（第2版）[M]. 陈晓亮, 译. 北京: 人民邮电出版社, 2017.

Kazuki Sakamoto,Tomohiko Furumoto. Objective-C高级编程：iOS与OS X多线程和内存管理[M]. 黎华, 译. 北京: 人民邮电出版社, 2013.

Erica Sadun. iOSAuto Layout开发秘籍（第2版）[M]. 孟立标, 译. 北京: 清华大学出版社, 2015.

珲少. iOS性能优化实战[M]. 北京: 电子工业出版社, 2019.

罗巍. iOS应用逆向与安全之道[M]. 北京: 机械工业出版社, 2020.

Gaurav Vaish. 高性能iOS应用开发[M]. 梁士兴等, 译. 北京: 人民邮电出版社, 2017.

刘浩. MATLAB R2020a完全自学一本通 [M]. 北京: 电子工业出版社, 2020.

天工在线. MATLAB 2020从入门到精通 [M]. 北京: 中国水利水电出版社, 2020.

苗志宏, 马金强. MATLAB面向对象程序设计[M]. 北京: 电子工业出版社, 2014.

徐潇, 李远 . MATLAB面向对象编程——从入门到设计模式（第2版）[M]. 北京: 北京航空航天大学出版社, 2017.

王文峰等. MATLAB计算机视觉与机器认知[M]. 北京: 北京航空航天大学, 2017.

杨淑莹, 郑清春. 模式识别与智能计算——MATLAB技术实现（第4版）[M]. 北京: 电子工业版社, 2019.

Eric Matthes.Python编程：从入门到实践（第2版）[M]. 袁国忠, 译. 北京: 人民邮电出版社, 2020.

Magnus LieHetland. Python基础教程（第3版）[M]. 袁国忠, 译. 北京: 人民邮电出版社, 2018.

Luciano Ramalho. 流畅的Python [M]. 安道等, 译. 北京: 人民邮电出版社, 2017.

Brett Slatkin. EffectivePython：编写高质量Python代码的90个有效方法（第2版）[M]. 爱飞翔, 译. 北京: 机械工业出版社, 2021.

Jan Erik Solem.Python计算机视觉编程[M]. 朱文涛等, 译. 北京: 人民邮电出版社, 2014.

Andreas C. Müller.Python机器学习基础教程[M]. 张亮, 译. 北京: 人民邮电出版社, 2018.

魏坤. Julia语言程序设计[M]. 北京: 机械工业出版社, 2018.

郝林. Julia编程基础（第2版）[M]. 北京: 人民邮电出版社, 2020.

Ben Lauwens, AllenB. Downey. Think Julia [M]. Sebastopol: O’Reilly, 2019.

Jalem Raj Rohit.Julia Cookbook [M]. Birmingham: Packt Publishing, 2018.

ZachariasVoulgaris. Julia数据科学应用 [M]. 陈光欣, 译. 北京: 人民邮电出版社, 2018.

朱红庆. Julia机器学习核心编程：人人可用的高性能科学计算[M]. 北京: 电子工业出版社, 2019.

Norman Matloff. R语言编程艺术[M]. 陈堰平, 译. 北京: 机械工业出版社, 2013.

Andy Nicholls,Richard Pugh, Aimee Gott. R语言入门经典[M]. 姜佑等, 译. 北京: 人民邮电出版社, 2018.

Robert I.Kabacoff. R语言实战（第2版）[M]. 王小宁等, 译. 北京: 人民邮电出版社, 2016.

Hadley Wickham. 高级R语言编程指南[M]. 潘文捷等, 译. 北京: 机械工业出版社, 2020.

Brett Lantz. 机器学习与R语言（第2版）[M]. 李洪成等, 译. 北京: 机械工业出版社, 2017.

程乾, 刘永, 高博. R语言数据分析与可视化从入门到精通[M]. 北京: 北京大学出版社, 2020.

周伟明.程序员的十层楼(一、二、三)[J]. 程序员, 2009(6):134-136;2009(7):118-120; 2009(8):134-136.

注：本文版权归作者个人所有，如需转载请联系作者，未经授权不得转载。

C++快速扫盲（提升篇）

本文摘自黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难课程讲义

C++提高编程

本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用

1 模板

1.1 模板的概念

模板就是建立通用的模具，大大提高复用性

模板的特点：

模板不可以直接使用，它只是一个框架
模板的通用并不是万能的

1.2 函数模板

C++另一种编程思想称为泛型编程，主要利用的技术就是模板
C++提供两种模板机制:函数模板和类模板

1.2.1 函数模板语法

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：

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

解释：

template — 声明创建模板

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

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

示例：

//交换整型函数
void swapInt(int& a, int& b) 
	int temp = a;
	a = b;
	b = temp;


//交换浮点型函数
void swapDouble(double& a, double& b) 
	double temp = a;
	a = b;
	b = temp;


//利用模板提供通用的交换函数
template<typename T>
void mySwap(T& a, T& b)

	T temp = a;
	a = b;
	b = temp;


void test01()

	int a = 10;
	int b = 20;
	
	//swapInt(a, b);

	//利用模板实现交换
	//1、自动类型推导
	mySwap(a, b);

	//2、显示指定类型
	mySwap<int>(a, b);

	cout << "a = " << a << endl;
	cout << "b = " << b << endl;



int main() 

	test01();

	system("pause");

	return 0;

总结：

函数模板利用关键字 template
使用函数模板有两种方式：自动类型推导、显示指定类型
模板的目的是为了提高复用性，将类型参数化

1.2.2 函数模板注意事项

注意事项：

自动类型推导，必须推导出一致的数据类型T,才可以使用
模板必须要确定出T的数据类型，才可以使用

示例：

//利用模板提供通用的交换函数
template<class T>
void mySwap(T& a, T& b)

	T temp = a;
	a = b;
	b = temp;



// 1、自动类型推导，必须推导出一致的数据类型T,才可以使用
void test01()

	int a = 10;
	int b = 20;
	char c = 'c';

	mySwap(a, b); // 正确，可以推导出一致的T
	//mySwap(a, c); // 错误，推导不出一致的T类型



// 2、模板必须要确定出T的数据类型，才可以使用
template<class T>
void func()

	cout << "func 调用" << endl;


void test02()

	//func(); //错误，模板不能独立使用，必须确定出T的类型
	func<int>(); //利用显示指定类型的方式，给T一个类型，才可以使用该模板


int main() 

	test01();
	test02();

	system("pause");

	return 0;

总结：

使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

1.2.3 函数模板案例

案例描述：

利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
排序规则从大到小，排序算法为选择排序
分别利用char数组和int数组进行测试

示例：

//交换的函数模板
template<typename T>
void mySwap(T &a, T&b)

	T temp = a;
	a = b;
	b = temp;



template<class T> // 也可以替换成typename
//利用选择排序，进行对数组从大到小的排序
void mySort(T arr[], int len)

	for (int i = 0; i < len; i++)
	
		int max = i; //最大数的下标
		for (int j = i + 1; j < len; j++)
		
			if (arr[max] < arr[j])
			
				max = j;
			
		
		if (max != i) //如果最大数的下标不是i，交换两者
		
			mySwap(arr[max], arr[i]);
		
	

template<typename T>
void printArray(T arr[], int len) 

	for (int i = 0; i < len; i++) 
		cout << arr[i] << " ";
	
	cout << endl;

void test01()

	//测试char数组
	char charArr[] = "bdcfeagh";
	int num = sizeof(charArr) / sizeof(char);
	mySort(charArr, num);
	printArray(charArr, num);


void test02()

	//测试int数组
	int intArr[] =  7, 5, 8, 1, 3, 9, 2, 4, 6 ;
	int num = sizeof(intArr) / sizeof(int);
	mySort(intArr, num);
	printArray(intArr, num);


int main() 

	test01();
	test02();

	system("pause");

	return 0;

总结：模板可以提高代码复用，需要熟练掌握

1.2.4 普通函数与函数模板的区别

普通函数与函数模板区别：

普通函数调用时可以发生自动类型转换（隐式类型转换）
函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
如果利用显示指定类型的方式，可以发生隐式类型转换

示例：

//普通函数
int myAdd01(int a, int b)

	return a + b;


//函数模板
template<class T>
T myAdd02(T a, T b)  

	return a + b;


//使用函数模板时，如果用自动类型推导，不会发生自动类型转换,即隐式类型转换
void test01()

	int a = 10;
	int b = 20;
	char c = 'c';
	
	cout << myAdd01(a, c) << endl; //正确，将char类型的'c'隐式转换为int类型  'c' 对应 ASCII码 99

	//myAdd02(a, c); // 报错，使用自动类型推导时，不会发生隐式类型转换

	myAdd02<int>(a, c); //正确，如果用显示指定类型，可以发生隐式类型转换


int main() 

	test01();

	system("pause");

	return 0;

总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

1.2.5 普通函数与函数模板的调用规则

调用规则如下：

如果函数模板和普通函数都可以实现，优先调用普通函数
可以通过空模板参数列表来强制调用函数模板
函数模板也可以发生重载
如果函数模板可以产生更好的匹配,优先调用函数模板

示例：

//普通函数与函数模板调用规则
void myPrint(int a, int b)

	cout << "调用的普通函数" << endl;


template<typename T>
void myPrint(T a, T b) 
 
	cout << "调用的模板" << endl;


template<typename T>
void myPrint(T a, T b, T c) 
 
	cout << "调用重载的模板" << endl; 


void test01()

	//1、如果函数模板和普通函数都可以实现，优先调用普通函数
	// 注意 如果告诉编译器  普通函数是有的，但只是声明没有实现，或者不在当前文件内实现，就会报错找不到
	int a = 10;
	int b = 20;
	myPrint(a, b); //调用普通函数

	//2、可以通过空模板参数列表来强制调用函数模板
	myPrint<>(a, b); //调用函数模板

	//3、函数模板也可以发生重载
	int c = 30;
	myPrint(a, b, c); //调用重载的函数模板

	//4、 如果函数模板可以产生更好的匹配,优先调用函数模板
	char c1 = 'a';
	char c2 = 'b';
	myPrint(c1, c2); //调用函数模板


int main() 

	test01();

	system("pause");

	return 0;

总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

1.2.6 模板的局限性

局限性：

模板的通用性并不是万能的

例如：

	template<class T>
	void f(T a, T b)
	 
    	a = b;

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

再例如：

	template<class T>
	void f(T a, T b)
	 
    	if(a > b)  ...

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

示例：

#include<iostream>using namespace std;#include <string>class Personpublic:	Person(string name, int age)			this->m_Name = name;		this->m_Age = age;		string m_Name;	int m_Age;;//普通函数模板template<class T>bool myCompare(T& a, T& b)	if (a == b)			return true;		else			return false;	//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型//具体化优先于常规模板template<> bool myCompare(Person &p1, Person &p2)	if ( p1.m_Name  == p2.m_Name && p1.m_Age == p2.m_Age)			return true;		else			return false;	void test01()	int a = 10;	int b = 20;	//内置数据类型可以直接使用通用的函数模板	bool ret = myCompare(a, b);	if (ret)			cout << "a == b " << endl;		else			cout << "a != b " << endl;	void test02()	Person p1("Tom", 10);	Person p2("Tom", 10);	//自定义数据类型，不会调用普通的函数模板	//可以创建具体化的Person数据类型的模板，用于特殊处理这个类型	bool ret = myCompare(p1, p2);	if (ret)			cout << "p1 == p2 " << endl;		else			cout << "p1 != p2 " << endl;	int main() 	test01();	test02();	system("pause");	return 0;

总结：

利用具体化的模板，可以解决自定义类型的通用化
学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3 类模板

1.3.1 类模板语法

类模板作用：

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

语法：

template<typename T>类

解释：

template — 声明创建模板

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

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

示例：

#include <string>//类模板template<class NameType, class AgeType> class Personpublic:	Person(NameType name, AgeType age)			this->mName = name;		this->mAge = age;		void showPerson()			cout << "name: " << this->mName << " age: " << this->mAge << endl;	public:	NameType mName;	AgeType mAge;;void test01()	// 指定NameType 为string类型，AgeType 为 int类型	Person<string, int>P1("孙悟空", 999);	P1.showPerson();int main() 	test01();	system("pause");	return 0;

总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

1.3.2 类模板与函数模板区别

类模板与函数模板区别主要有两点：

类模板没有自动类型推导的使用方式
类模板在模板参数列表中可以有默认参数

示例：

#include <string>//类模板template<class NameType, class AgeType = int> class Personpublic:	Person(NameType name, AgeType age)			this->mName = name;		this->mAge = age;		void showPerson()			cout << "name: " << this->mName << " age: " << this->mAge << endl;	public:	NameType mName;	AgeType mAge;;//1、类模板没有自动类型推导的使用方式void test01()	// Person p("孙悟空", 1000); // 错误 类模板使用时候，不可以用自动类型推导	Person <string ,int>p("孙悟空", 1000); //必须使用显示指定类型的方式，使用类模板	p.showPerson();//2、类模板在模板参数列表中可以有默认参数void test02()	Person <string> p("猪八戒", 999); //类模板中的模板参数列表 可以指定默认参数	p.showPerson();int main() 	test01();	test02();	system("pause");	return 0;

总结：

类模板使用只能用显示指定类型方式
类模板中的模板参数列表可以有默认参数

1.3.3 类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

普通类中的成员函数一开始就可以创建
类模板中的成员函数在调用时才创建

示例：

class Person1public:	void showPerson1()			cout << "Person1 show" << endl;	;class Person2public:	void showPerson2()			cout << "Person2 show" << endl;	;template<class T>class MyClasspublic:	T obj;	//类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成	void fun1()  obj.showPerson1(); 	void fun2()  obj.showPerson2(); ;void test01()	MyClass<Person1> m;		m.fun1();	//m.fun2();//编译会出错，说明函数调用才会去创建成员函数int main() 	test01();	system("pause");	return 0;

总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建

1.3.4 类模板对象做函数参数

学习目标：

类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

指定传入的类型 — 直接显示对象的数据类型
参数模板化 — 将对象中的参数变为模板进行传递
整个类模板化 — 将这个对象类型模板化进行传递

示例：

#include <string>//类模板template<class NameType, class AgeType = int> class Personpublic:	Person(NameType name, AgeType age)			this->mName = name;		this->mAge = age;		void showPerson()			cout << "name: " << this->mName << " age: " << this->mAge << endl;	public:	NameType mName;	AgeType mAge;;//1、指定传入的类型void printPerson1(Person<string, int> &p) 	p.showPerson();void test01()	Person <string, int >p("孙悟空", 100);	printPerson1(p);//2、参数模板化template <class T1, class T2>void printPerson2(Person<T1, T2>&p)	p.showPerson();	cout << "T1的类型为： " << typeid(T1).name() << endl;	cout << "T2的类型为： " << typeid(T2).name() << endl;void test02()	Person <string, int >p("猪八戒", 90);	printPerson2(p);//3、整个类模板化template<class T>void printPerson3(T & p)	cout << "T的类型为： " << typeid(T).name() << endl;	p.showPerson();void test03()	Person <string, int >p("唐僧", 30);	printPerson3(p);int main() 	test01();	test02();	test03();	system("pause");	return 0;

总结：

通过类模板创建的对象，可以有三种方式向函数中进行传参
使用比较广泛是第一种：指定传入的类型

1.3.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
如果不指定，编译器无法给子类分配内存
如果想灵活指定出父类中T的类型，子类也需变为类模板

示例：

template<class T>class Base	T m;;//class Son:public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承class Son :public Base<int> //必须指定一个类型;void test01()	Son c;//类模板继承类模板 ,可以用T2指定父类中的T类型template<class T1, class T2>class Son2 :public Base<T2>public:	Son2()			cout << typeid(T1).name() << endl;		cout << typeid(T2).name() << endl;	;void test02()	Son2<int, char> child1;int main() 	test01();	test02();	system("pause");	return 0;

总结：如果父类是类模板，子类需要指定出父类中T的数据类型

1.3.6 类模板成员函数类外实现

学习目标：能够掌握类模板中的成员函数类外实现

示例：

#include <string>//类模板中成员函数类外实现template<class T1, class T2>class Person public:	//成员函数类内声明	Person(T1 name, T2 age);	void showPerson();public:	T1 m_Name;	T2 m_Age;;//构造函数 类外实现template<class T1, class T2>Person<T1, T2>::Person(T1 name, T2 age) 	this->m_Name = name;	this->m_Age = age;//成员函数 类外实现template<class T1, class T2>void Person<T1, T2>::showPerson() 	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;void test01()	Person<string, int> p("Tom", 20);	p.showPerson();int main() 	test01();	system("pause");	return 0;

总结：类模板中成员函数类外实现时，需要加上模板参数列表

1.3.7 类模板分文件编写

学习目标：

掌握类模板成员函数分文件编写产生的问题以及解决方式

问题：

类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

示例：

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 showPerson();public:	T1 m_Name;	T2 m_Age;;//构造函数 类外实现template<class T1, class T2>Person<T1, T2>::Person(T1 name, T2 age) 	this->m_Name = name;	this->m_Age = age;//成员函数 类外实现template<class T1, class T2>void Person<T1, T2>::showPerson() 	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;

类模板分文件编写.cpp中代码

#include<iostream>using namespace std;//#include "person.h"#include "person.cpp" //解决方式1，包含cpp源文件//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp#include "person.hpp"void test01()	Person<string, int> p("Tom", 10);	p.showPerson();int main() 	test01();	system("pause");	return 0;

总结：主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

1.3.8 类模板与友元

学习目标：

掌握类模板配合友元函数的类内和类外实现

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

示例：

#include <string>//2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元template<class T1, class T2> class Person;//如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到//template<class T1, class T2> void printPerson2(Person<T1, T2> & p); template<class T1, class T2>void printPerson2(Person<T1, T2> & p)	cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;template<class T1, class T2>class Person	//1、全局函数配合友元   类内实现	friend void printPerson(Person<T1, T2> & p)			cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;		//全局函数配合友元  类外实现	friend void printPerson2<>(Person<T1, T2> & p);public:	Person(T1 name, T2 age)			this->m_Name = name;		this->m_Age = age;	private:	T1 m_Name;	T2 m_Age;;//1、全局函数在类内实现void test01()	Person <string, int >p("Tom", 20);	printPerson(p);//2、全局函数在类外实现void test02()	Person <string, int >p("Jerry", 30);	printPerson2(p);int main() 	//test01();	test02();	system("pause");	return 0;

总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别

1.3.9 类模板案例

案例描述: 实现一个通用的数组类，要求如下：

可以对内置数据类型以及自定义数据类型的数据进行存储
将数组中的数据存储到堆区
构造函数中可以传入数组的容量
提供对应的拷贝构造函数以及operator=防止浅拷贝问题
提供尾插法和尾删法对数组中的数据进行增加和删除
可以通过下标的方式访问数组中的元素
可以获取数组中当前元素个数和数组的容量

示例：

myArray.hpp中代码

#pragma once#include <iostream>using namespace std;template<class T>class MyArraypublic:    	//构造函数	MyArray(int capacity)			this->m_Capacity = capacity;		this->m_Size = 0;		pAddress = new T[this->m_Capacity];		//拷贝构造	MyArray(const MyArray & arr)			this->m_Capacity = arr.m_Capacity;		this->m_Size = arr.m_Size;		this->pAddress = new T[this->m_Capacity];		for (int i = 0; i < this->m_Size; i++)					//如果T为对象，而且还包含指针，必须需要重载 = 操作符，因为这个等号不是 构造 而是赋值，			// 普通类型可以直接= 但是指针类型需要深拷贝			this->pAddress[i] = arr.pAddress[i];				//重载= 操作符  防止浅拷贝问题	MyArray& operator=(const MyArray& myarray) 		if (this->pAddress != NULL) 			delete[] this->pAddress;			this->m_Capacity = 0;			this->m_Size = 0;				this->m_Capacity = myarray.m_Capacity;		this->m_Size = myarray.m_Size;		this->pAddress = new T[this->m_Capacity];		for (int i = 0; i < this->m_Size; i++) 			this->pAddress[i] = myarray[i];				return *this;		//重载[] 操作符  arr[0]	T& operator [](int index)			return this->pAddress[index]; //不考虑越界，用户自己去处理		//尾插法	void Push_back(const T & val)			if (this->m_Capacity == this->m_Size)					return;				this->pAddress[this->m_Size] = val;		this->m_Size++;		//尾删法	void Pop_back()			if (this->m_Size == 0)					return;				this->m_Size--;		//获取数组容量	int getCapacity()			return this->m_Capacity;		//获取数组大小	int	getSize()			return this->m_Size;		//析构	~MyArray()			if (this->pAddress != NULL)					delete[] this->pAddress;			this->pAddress = NULL;			this->m_Capacity = 0;			this->m_Size = 0;			private:	T * pAddress;  //指向一个堆空间，这个空间存储真正的数据	int m_Capacity; //容量	int m_Size;   // 大小;

类模板案例—数组类封装.cpp中

#include "myArray.hpp"#include <string>void printIntArray(MyArray<int>& arr) 	for (int i = 0; i < arr.getSize(); i++) 		cout << arr[i] << " ";		cout << endl;//测试内置数据类型void test01()	MyArray<int> array1(10);	for (int i = 0; i < 10; i++)			array1.Push_back(i);		cout << "array1打印输出：" << endl;	printIntArray(array1);	cout << "array1的大小：" << array1.getSize() << endl;	cout << "array1的容量：" << array1.getCapacity() << endl;	cout << "--------------------------" << endl;	MyArray<int> array2(array1);	array2.Pop_back();	cout << "array2打印输出：" << endl;	printIntArray(array2);	cout << "array2的大小：" << array2.getSize() << endl;	cout << "array2的容量：" << array2.getCapacity() << endl;//测试自定义数据类型class Person public:	Person()  		Person(string name, int age) 		this->m_Name = name;		this->m_Age = age;	public:	string m_Name;	int m_Age;;void printPersonArray(MyArray<Person>& personArr)	for (int i = 0; i < personArr.getSize(); i++) 		cout << "姓名：" << personArr[i].m_Name << " 年龄： " << personArr[i].m_Age << endl;	void test02()	//创建数组	MyArray<Person> pArray(10);	Person p1("孙悟空", 30);	Person p2("韩信", 20);	Person p3("妲己", 18);	Person p4("王昭君", 15);	Person p5("赵云", 24);	//插入数据	pArray.Push_back(p1);	pArray.Push_back(p2);	pArray.Push_back(p3);	pArray.Push_back(p4);	pArray.Push_back(p5);	printPersonArray(pArray);	cout << "pArray的大小：" << pArray.getSize() << endl;	cout << "pArray的容量：" << pArray.getCapacity() << endl;int main() 	//test01();	test02();	system("pause");	return 0;

总结：

能够利用所学知识点实现通用的数组

2 STL初识

2.1 STL的诞生

长久以来，软件界一直希望建立一种可重复利用的东西
C++的面向对象和泛型编程思想，目的就是复用性的提升
大多情况下，数据结构和算法都未能有一套标准,导致被迫从事大量重复工作
为了建立数据结构和算法的一套标准,诞生了STL

2.2 STL基本概念

STL(Standard Template Library,标准模板库)
STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator)
容器和算法之间通过迭代器进行无缝连接。
STL 几乎所有的代码都采用了模板类或者模板函数

2.3 STL六大组件

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据。
算法：各种常用的算法，如sort、find、copy、for_each等
迭代器：扮演了容器与算法之间的胶合剂。
仿函数：行为类似函数，可作为算法的某种策略。
适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
空间配置器：负责空间的配置与管理。

2.4 STL中容器、算法、迭代器

**容器：**置物之所也

STL容器就是将运用最广泛的一些数据结构实现出来

常用的数据结构：数组, 链表,树, 栈, 队列, 集合, 映射表等

这些容器分为序列式容器和关联式容器两种:

序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系

**算法：**问题之解法也

有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)

算法分为:质变算法和非质变算法。

质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等

非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等

**迭代器：**容器和算法之间粘合剂

提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。

每个容器都有自己专属的迭代器

迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

迭代器种类：

种类	功能	支持运算
输入迭代器	对数据的只读访问	只读，支持++、==、！=
输出迭代器	对数据的只写访问	只写，支持++
前向迭代器	读写操作，并能向前推进迭代器	读写，支持++、==、！=
双向迭代器	读写操作，并能向前和向后操作	读写，支持++、–，
随机访问迭代器	读写操作，可以以跳跃的方式访问任意数据，功能最强的迭代器	读写，支持++、–、[n]、-n、<、<=、>、>=

常用的容器中迭代器种类为双向迭代器，和随机访问迭代器

2.5 容器算法迭代器初识

了解STL中容器、算法、迭代器概念之后，我们利用代码感受STL的魅力

STL中最常用的容器为Vector，可以理解为数组，下面我们将学习如何向这个容器中插入数据、并遍历这个容器

2.5.1 vector存放内置数据类型

容器： vector

算法： for_each

迭代器： vector<int>::iterator

示例：

#include <vector>
#include <algorithm>

void MyPrint(int val)

	cout << val << endl;


void test01() 

	//创建vector容器对象，并且通过模板参数指定容器中存放的数据的类型
	vector<int> v;
	//向容器中放数据
	v.push_back(10);
	v.push_back(20);
	v.push_back(30);
	v.push_back(40);

	//每一个容器都有自己的迭代器，迭代器是用来遍历容器中的元素
	//v.begin()返回迭代器，这个迭代器指向容器中第一个数据
	//v.end()返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置
	//vector<int>::iterator 拿到vector<int>这种容器的迭代器类型

	vector<int>::iterator pBegin = v.begin();
	vector<int>::iterator pEnd = v.end();

	//第一种遍历方式：
	while (pBegin != pEnd) 
		cout << *pBegin << endl;
		pBegin++;
	

	
	//第二种遍历方式：
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 
		cout << *it << endl;
	
	cout << endl;

	//第三种遍历方式：
	//使用STL提供标准遍历算法  头文件 algorithm
	for_each(v.begin(), v.end(), MyPrint);


int main() 

	test01();

	system("pause");

	return 0;

2.5.2 Vector存放自定义数据类型

学习目标：vector中存放自定义数据类型，并打印输出

示例：

#include <vector>#include <string>//自定义数据类型class Person public:	Person(string name, int age) 		mName = name;		mAge = age;	public:	string mName;	int mAge;;//存放对象void test01() 	vector<Person> v;	//创建数据	Person p1("aaa", 10);	Person p2("bbb", 20);	Person p3("ccc", 30);	Person p4("ddd", 40);	Person p5("eee", 50);	v.push_back(p1);	v.push_back(p2);	v.push_back(p3);	v.push_back(p4);	v.push_back(p5);	for (vector<Person>::iterator it = v.begin(); it != v.end(); it++) 		cout << "Name:" << (*it).mName << " Age:" << (*it).mAge << endl;	//放对象指针void test02() 	vector<Person*> v;	//创建数据	Person p1("aaa", 10);	Person p2("bbb", 20);	Person p3("ccc", 30);	Person p4("ddd", 40);	Person p5("eee", 50);	v.push_back(&p1);	v.push_back(&p2);	v.push_back(&p3);	v.push_back(&p4);	v.push_back(&p5);	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) 		Person * p = (*it);		cout << "Name:" << p->mName << " Age:" << (*it)->mAge << endl;	int main() 	test01();    	test02();	system("pause");	return 0;

2.5.3 Vector容器嵌套容器

学习目标：容器中嵌套容器，我们将所有数据进行遍历输出

示例：

#include <vector>//容器嵌套容器void test01() 	vector< vector<int> >  v;	vector<int> v1;	vector<int> v2;	vector<int> v3;	vector<int> v4;	for (int i = 0; i < 4; i++) 		v1.push_back(i + 1);		v2.push_back(i + 2);		v3.push_back(i + 3);		v4.push_back(i + 4);		//将容器元素插入到vector v中	v.push_back(v1);	v.push_back(v2);	v.push_back(v3);	v.push_back(v4);	for (vector<vector<int>>::iterator it = v.begin(); it != v.end(); it++) 		for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++) 			cout << *vit << " ";				cout << endl;	int main() 	test01();	system("pause");	return 0;

3 STL- 常用容器

3.1 string容器

3.1.1 string基本概念

本质：

string是C++风格的字符串，而string本质上是一个类

string和char * 区别：

char * 是一个指针
string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

特点：

string 类内部封装了很多成员方法

例如：查找find，拷贝copy，删除delete 替换replace，插入insert

string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

3.1.2 string构造函数

构造函数原型：

string(); //创建一个空的字符串例如: string str;
string(const char* s); //使用字符串s初始化
string(const string& str); //使用一个string对象初始化另一个string对象
string(int n, char c); //使用n个字符c初始化

示例：

#include <string>
//string构造
void test01()

	string s1; //创建空字符串，调用无参构造函数
	cout << "str1 = " << s1 << endl;

	const char* str = "hello world";
	string s2(str); //把c_string转换成了string

	cout << "str2 = " << s2 << endl;

	string s3(s2); //调用拷贝构造函数
	cout << "str3 = " << s3 << endl;

	string s4(10, 'a');
	cout << "str3 = " << s3 << endl;


int main() 

	test01();

	system("pause");

	return 0;

总结：string的多种构造方式没有可比性，灵活使用即可

3.1.3 string赋值操作

功能描述：

给string字符串进行赋值

赋值的函数原型：

string& operator=(const char* s); //char*类型字符串赋值给当前的字符串
string& operator=(const string &s); //把字符串s赋给当前的字符串
string& operator=(char c); //字符赋值给当前的字符串
string& assign(const char *s); //把字符串s赋给当前的字符串
string& assign(const char *s, int n); //把字符串s的前n个字符赋给当前的字符串
string& assign(const string &s); //把字符串s赋给当前字符串
string& assign(int n, char c); //用n个字符c赋给当前字符串

示例：

//赋值void test01()	string str1;	str1 = "hello world";	cout << "str1 = " << str1 << endl;	string str2;	str2 = str1;	cout << "str2 = " << str2 << endl;	string str3;	str3 = 'a';	cout << "str3 = " << str3 << endl;	string str4;	str4.assign("hello c++");	cout << "str4 = " << str4 << endl;	string str5;	str5.assign("hello c++",5);	cout << "str5 = " << str5 << endl;	string str6;	str6.assign(str5);	cout << "str6 = " << str6 << endl;	string str7;	str7.assign(5, 'x');	cout << "str7 = " << str7 << endl;int main() 	test01();	system("pause");	return 0;

总结：

string的赋值方式很多，operator= 这种方式是比较实用的

3.1.4 string字符串拼接

功能描述：

实现在字符串末尾拼接字符串

函数原型：

string& operator+=(const char* str); //重载+=操作符
string& operator+=(const char c); //重载+=操作符
string& operator+=(const string& str); //重载+=操作符
string& append(const char *s); //把字符串s连接到当前字符串结尾
string& append(const char *s, int n); //把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s); //同operator+=(const string& str)
string& append(const string &s, int pos, int n);//字符串s中从pos开始的n个字符连接到字符串结尾

示例：

//字符串拼接void test01()	string str1 = "我";	str1 += "爱玩游戏";	cout << "str1 = " << str1 << endl;		str1 += ':';	cout << "str1 = " << str1 << endl;	string str2 = "LOL DNF";	str1 += str2;	cout << "str1 = " << str1 << endl;	string str3 = "I";	str3.append(" love ");	str3.append("game abcde", 4);	//str3.append(str2);	str3.append(str2, 4, 3); // 从下标4位置开始 ，截取3个字符，拼接到字符串末尾	cout << "str3 = " << str3 << endl;int main() 	test01();	system("pause");	return 0;

总结：字符串拼接的重载版本很多，初学阶段记住几种即可

3.1.5 string查找和替换

功能描述：

查找：查找指定字符串是否存在
替换：在指定的位置替换字符串

函数原型：

int find(const string& str, int pos = 0) const; //查找str第一次出现位置,从pos开始查找
int find(const char* s, int pos = 0) const; //查找s第一次出现位置,从pos开始查找
int find(const char* s, int pos, int n) const; //从pos位置查找s的前n个字符第一次位置
int find(const char c, int pos = 0) const; //查找字符c第一次出现位置
int rfind(const string& str, int pos = npos) const; //查找str最后一次位置,从pos开始查找
int rfind(const char* s, int pos = npos) const; //查找s最后一次出现位置,从pos开始查找
int rfind(const char* s, int pos, int n) const; //从pos查找s的前n个字符最后一次位置
int rfind(const char c, int pos = 0) const; //查找字符c最后一次出现位置
string& replace(int pos, int n, const string& str); //替换从pos开始n个字符为字符串str
string& replace(int pos, int n,const char* s); //替换从pos开始的n个字符为字符串s

示例：

//查找和替换void test01()	//查找	string str1 = "abcdefgde";	int pos = str1.find("de");	if (pos == -1)			cout << "未找到" << endl;		else			cout << "pos = " << pos << endl;			pos = str1.rfind("de");	cout << "pos = " << pos << endl;void test02()	//替换	string str1 = "abcdefgde";	str1.replace(1, 3, "1111");	cout << "str1 = " << str1 << endl;int main() 	//test01();	//test02();	system("pause");	return 0;

总结：

find查找是从左往后，rfind从右往左
find找到字符串后返回查找的第一个字符位置，找不到返回-1
replace在替换时，要指定从哪个位置起，多少个字符，替换成什么样的字符串

3.1.6 string字符串比较

功能描述：

字符串之间的比较

比较方式：

字符串比较是按字符的ASCII码进行对比

= 返回 0

> 返回 1

< 返回 -1

函数原型：

int compare(const string &s) const; //与字符串s比较
int compare(const char *s) const; //与字符串s比较

示例：

//字符串比较void test01()	string s1 = "hello";	string s2 = "aello";	int ret = s1.compare(s2);	if (ret == 0) 		cout << "s1 等于 s2" << endl;		else if (ret > 0)			cout << "s1 大于 s2" << endl;		else			cout << "s1 小于 s2" << endl;	int main() 	test01();	system("pause");	return 0;

总结：字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大

3.1.7 string字符存取

string中单个字符存取方式有两种

char& operator[](int n); //通过[]方式取字符
char& at(int n); //通过at方法获取字符

示例：

void test01()	string str = "hello world";	for (int i = 0; i < str.size(); i++)			cout << str[i] << " ";		cout << endl;	for (int i = 0; i < str.size(); i++)			cout << str.at(i) << " ";		cout << endl;	//字符修改	str[0] = 'x';	str.at(1) = 'x';	cout << str << endl;	int main() 	test01();	system("pause");	return 0;

总结：string字符串中单个字符存取有两种方式，利用 [ ] 或 at

3.1.8 string插入和删除

功能描述：

对string字符串进行插入和删除字符操作

函数原型：

string& insert(int pos, const char* s); //插入字符串
string& insert(int pos, const string& str); //插入字符串
string& insert(int pos, int n, char c); //在指定位置插入n个字符c
string& erase(int pos, int n = npos); //删除从Pos开始的n个字符

示例：

//字符串插入和删除void test01()	string str = "hello";	str.insert(1, "111");	cout << str << endl;	str.erase(1, 3);  //从1号位置开始3个字符	cout << str << endl;int main() 	test01();	system("pause");	return 0;

**总结：**插入和删除的起始下标都是从0开始

3.1.9 string子串

功能描述：

从字符串中获取想要的子串

函数原型：

string substr(int pos = 0, int n = npos) const; //返回由pos开始的n个字符组成的字符串

示例：

//子串void test01()	string str = "abcdefg";	string subStr = str.substr(1, 3);	cout << "subStr = " << subStr << endl;	string email = "hello@sina.com";	int pos = email.find("@");	string username = email.substr(0, pos);	cout << "username: " << username << endl;int main() 	test01();	system("pause");	return 0;

**总结：**灵活的运用求子串功能，可以在实际开发中获取有效的信息

3.2 vector容器

3.2.1 vector基本概念

功能：

vector数据结构和数组非常相似，也称为单端数组

vector与普通数组区别：

不同之处在于数组是静态空间，而vector可以动态扩展

动态扩展：

并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
vector容器的迭代器是支持随机访问的迭代器

3.2.2 vector构造函数

功能描述：

创建vector容器

函数原型：

vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem); //构造函数将n个elem拷贝给本身。
vector(const vector &vec); //拷贝构造函数。

示例：

#include <vector>

void printVector(vector<int>& v) 

	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 
		cout << *it << " ";
	
	cout << endl;


void test01()

	vector<int> v1; //无参构造
	for (int i = 0; i < 10; i++)
	
		v1.push_back(i);
	
	printVector(v1);

	vector<int> v2(v1.begin(), v1.end());
	printVector(v2);

	vector<int> v3(10, 100);
	printVector(v3);
	
	vector<int> v4(v3);
	printVector(v4);


int main() 

	test01();

	system("pause");

	return 0;

**总结：**vector的多种构造方式没有可比性，灵活使用即可

3.2.3 vector赋值操作

功能描述：

给vector容器进行赋值

函数原型：

vector& operator=(const vector &vec);//重载等号操作符
assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem); //将n个elem拷贝赋值给本身。

示例：

#include <vector>void printVector(vector<int>& v) 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 		cout << *it << " ";		cout << endl;//赋值操作void test01()	vector<int> v1; //无参构造	for (int i = 0; i < 10; i++)			v1.push_back(i);		printVector(v1);	vector<int>v2;	v2 = v1;	printVector(v2);	vector<int>v3;	v3.assign(v1.begin(), v1.end());	printVector(v3);	vector<int>v4;	v4.assign(10, 100);	printVector(v4);int main() 	test01();	system("pause");	return 0;

总结： vector赋值方式比较简单，使用operator=，或者assign都可以

3.2.4 vector容量和大小

功能描述：

对vector容器的容量和大小操作

函数原型：

empty(); //判断容器是否为空
capacity(); //容器的容量
size(); //返回容器中元素的个数
resize(int num); //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除

示例：

#include <vector>void printVector(vector<int>& v) 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 		cout << *it << " ";		cout << endl;void test01()	vector<int> v1;	for (int i = 0; i < 10; i++)			v1.push_back(i);		printVector(v1);	if (v1.empty())			cout << "v1为空" << endl;		else			cout << "v1不为空" << endl;		cout << "v1的容量 = " << v1.capacity() << endl;		cout << "v1的大小 = " << v1.size() << endl;		//resize 重新指定大小 ，若指定的更大，默认用0填充新位置，可以利用重载版本替换默认填充	v1.resize(15,10);	printVector(v1);	//resize 重新指定大小 ，若指定的更小，超出部分元素被删除	v1.resize(5);	printVector(v1);int main() 	test01();	system("pause");	return 0;

总结：

判断是否为空 — empty
返回元素个数 — size
返回容器容量 — capacity
重新指定大小 — resize

3.2.5 vector插入和删除

功能描述：

对vector容器进行插入、删除操作

函数原型：

push_back(ele); //尾部插入元素ele
pop_back(); //删除最后一个元素
insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele
erase(const_iterator pos); //删除迭代器指向的元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
clear(); //删除容器中所有元素

示例：

#include <vector>void printVector(vector<int>& v) 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 		cout << *it << " ";		cout << endl;//插入和删除void test01()	vector<int> v1;	//尾插	v1.push_back(10);	v1.push_back(20);	v1.push_back(30);	v1.push_back(40);	v1.push_back(50);	printVector(v1);	//尾删	v1.pop_back();	printVector(v1);	//插入	v1.insert(v1.begin(), 100);	printVector(v1);	v1.insert(v1.begin(), 2, 1000);	printVector(v1);	//删除	v1.erase(v1.begin());	printVector(v1);	//清空	v1.erase(v1.begin(), v1.end());	v1.clear();	printVector(v1);int main() 	test01();	system("pause");	return 0;

总结：

尾插 — push_back
尾删 — pop_back
插入 — insert (位置迭代器)
删除 — erase （位置迭代器）
清空 — clear

3.2.6 vector数据存取

功能描述：

对vector中的数据的存取操作

函数原型：

at(int idx); //返回索引idx所指的数据
operator[]; //返回索引idx所指的数据
front(); //返回容器中第一个数据元素
back(); //返回容器中最后一个数据元素

示例：

#include <vector>void test01()	vector<int>v1;	for (int i = 0; i < 10; i++)			v1.push_back(i);		for (int i = 0; i < v1.size(); i++)			cout << v1[i] << " ";		cout << endl;	for (int i = 0; i < v1.size(); i++)			cout << v1.at(i) << " ";		cout << endl;	cout << "v1的第一个元素为： " << v1.front() << endl;	cout << "v1的最后一个元素为： " << v1.back() << endl;int main() 	test01();	system("pause");	return 0;

总结：

除了用迭代器获取vector容器中元素，[ ]和at也可以
front返回容器第一个元素
back返回容器最后一个元素

3.2.7 vector互换容器

功能描述：

实现两个容器内元素进行互换

函数原型：

swap(vec); // 将vec与本身的元素互换

示例：

#include <vector>void printVector(vector<int>& v) 	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) 		cout << *it << " ";		cout << endl;void test01()	vector<int>v1;	for (int i = 0; i < 10; i++)			v1.push_back(i);		printVector(v1);	vector<int>v2;	for (int i = 10; i > 0; i--)			v2.push_back(i);		printVector(v2);	//互换容器	cout << "互换后" << endl;	v1.swap(v2);	printVector(v1);	printVector(v2);void test02()	vector<int> v;	for (int i = 0; i < 100000; i++) 		v.push_back(i);		cout << "v的容量为：" << v.capacity() << endl;	cout << "v的大小为：" << v.size() << endl;	v.resize(3);	cout << "v的容量为：" << v.capacity() << endl;	cout << "v的大小为：" << v.size() << endl;	//收缩内存	vector<int>(v).swap(v); //匿名对象	cout << "v的容量为：" << v.capacity() << endl;	cout << "v的大小为：" << v.size() << endl;int main() 	test01();	test02();	system("pause");	return 0;

总结：swap可以使两个容器互换，可以达到实用的收缩内存效果

3.2.8 vector预留空间

功能描述：

减少vector在动态扩展容量时的扩展次数

函数原型：

reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。

示例：

#include <vector>void test01()	vector<int> v;	//预留空间	v.reserve(100000);	int num = 0;	int* p = NULL;	for (int i = 0; i < 100000; i++) 		v.push_back(i);		if (p != &v[0]) 			p = &v[0];			num++;				cout << "num:" << num << endl;int main() 	test01();    	system("pause");	return 0;

总结：如果数据量较大，可以一开始利用reserve预留空间

3.3 deque容器

3.3.1 deque容器基本概念

功能：

双端数组，可以对头端进行插入删除操作

deque与vector区别：

vector对于头部的插入删除效率低，数据量越大，效率越低
deque相对而言，对头部的插入删除速度回比vector快
vector访问元素时的速度会比deque快,这和两者内部实现有关

deque内部工作原理:

deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据

中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

deque容器的迭代器也是支持随机访问的

3.3.2 deque构造函数

功能描述：

deque容器构造

函数原型：

deque<T> deqT; //默认构造形式
deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。
deque(n, elem); //构造函数将n个elem拷贝给本身。
deque(const deque &deq); //拷贝构造函数

示例：

#include <deque>void printDeque(const deque<int>& d) 	for (deque<int>::const_iterator it = d.begin(); it != d.end(); it++) 		cout << *it << " ";		cout << endl;//deque构造void test01() 	deque<int> d1; //无参构造函数	for (int i = 0; i < 10; i++)			d1.push_back(i);		printDeque(d1);	deque<int> d2(d1.begin(),d1.end());	printDeque(d2);	deque<int>d3(10,100);	printDeque(d3);	deque<int>d4 = d3;	printDeque(d4);int main() 	test01();	system("pause");	return 0;

**总结：**deque容器和vector容器的构造方式几乎一致，灵活使用即可

3.3.3 deque赋值操作

功能描述：

给deque容器进行赋值

函数原型：

deque& operator=(const deque &deq);以上是关于桌面端编程之通过C++的标准模板库代码快速提高编程能力的主要内容，如果未能解决你的问题，请参考以下文章
c++提高编程 2 .STL初识《深入实践C++模板编程》之六——标准库中的容器 C++的探索路20标准模板库STL之STL的基本概念与容器 C++的探索路20标准模板库STL之STL的基本概念与容器吐血整理：C++编程语言资源汇总浅窥C++模板编程