【C++提高编程(一)】模板、STL基础概念

这部分主要学习C++标准模板库相关的内容

1模板

C++泛型编程的思想所利用的主要技术是模板；使用模板的目的是提高复用性，将类型参数化

C++提供两种模板机制函数模板和类模板

1.1 函数模板

1.1.1 函数模板语法及调用

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

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

template 声明创建模板

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

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

//调用函数模板的两种方式
//1. 自动类型推导
函数名(参数列表);	//编译器根据传入参数的类型自动推导T的类型
//2. 显式指定类型
函数名<数据类型>(参数列表);	//指定数据类型告知这次调用使用何种数据类型

1.1.2 函数模板的注意事项

• 自动类型推导必须(对参数)都推导出一致的数据类型T才可以使用
• 模板必须要确定出T的数据类型(函数中必须要有调用数据类型T的地方；或者在调用时使用显示指定类型的方法指明T的类型)

1.1.3 普通函数和函数模板的区别

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

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

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

1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表 函数名<>(参数列表); (即显示指定类型的括号中不填写类型)来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好的匹配，优先调用函数模板(即对于同一组输入，普通函数和函数模板都可以实现，但普通函数需要自动类型转换、函数模板不需要转换的化的情况下，优先调用函数模板)

1.1.5 模板的局限性

对于自定义数据类型或数组等作为函数参数的情况下，模板无法运行；

为此可以对模板进行重载，为这些特定的类型提供具体化的模板，解决了自定义类型的通用化

//函数模板定义，不可用于特殊数据类型
template<typename T>
函数名(参数列表){}
//函数模板重载，针对特定的数据类型提供具体化模板
template<> 返回值类型 函数名(特殊参数列表){}

1.2 类模板

1.2.1 类模板语法及调用

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

template<typename T1,typename T2...>
类定义

类模板和函数模板的语法类似，在声明模板template后加类，此类称为类模板

1.2.2 类模板与函数模板的区别

• 类模板没有自动类型推导的使用形式(C++11以前，C++17支持类模板自动类型推导)

  类名<类型1, 类型2...> 对象名(参数列表);//使用显示指定类型实例化对象
  类名 对象名(参数列表);	//C++17中支持对类模板的自动类型推导
  

• 类模板在模板参数列表中可以有默认参数

  template<typename T1, typename T2 = 类型1...>
  

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

普通类的成员函数一开始就可以创建(被加入到全局区中)，而类模板的成员函数在调用时才可以创建(编译器无法确认数据类型，更无法确认成员函数是被何种数据类型调用，因此需要在被实际对象调用时创建成员函数)

1.2.4 类模板对象做函数参数

类模板实例化出的对象向函数传参的方式有三种：

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

//实例化的类模板对象做参数
Person<string, int>p("123"，123)	
//1. 指定传入类型(最常用)
void printPerson1(Person<string, int>&p){}	
//2. 参数模板化
template<typename T1, typename T2>	
void printPerson2(Person<T1, T2>&p){}	
//传入对象的类型参数确定，T1、T2也可以确定（实质为创建一个函数模板，使其进行自动类型推导）

//3. 类模板化
template<class T>
void printPerson3(T &p){}					

对于模板自动推导，可以使用 typeid(T).name() 查看编译器推导出的数据类型

1.2.5 类模板与继承

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

template<typename T>
class Base{ T a };
class Son:public Base{};	//错误，必须知道父类T的类型才可以继承给子类
class Son:public Base<int>{};//正确
//想灵活指定父类T的类型，子类也要变为类模板
template<typename T>
class Son1:public Base<T>{}

1.2.6 类模板成员函数外实现

//创建类模板
template<typename T1, typename T2>
class Base{ 
    Base(T1 a, T2 b);
 	void M_Func(){}   
};
//构造函数类外实现
template<class T1, class T2>
Base<T1, T2>::Base(T1 a, T2 b){}
//成员函数类外实现
template<class T1, class T2>
void Base<classT1, classT2>::M_Func(){}

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

1.2.7 类模板分文件编写

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

解决方式：

1. 将主函数所在文件包含.h文件改为直接包含.cpp文件
2. (主流方法）将声明和实现写到同一个文件中，并更改后缀为.hpp，hpp是约定的名称，并不是强制

1.2.8 类模板与友元

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

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

//全局函数类内实现 - 直接在类内声明友元即可
template<class T1, class T2>
class Base{
    friend 返回值类型 函数名(Base<T1, T2> B){ 具体实现 }
}

//全局函数类外实现 - 需要提前让编译器知道全局函数的存在（综合考虑编译顺序）
//类的声明，让编译器知道Base类的存在
class Base;
//全局函数的类外实现，让编译器知道此函数的内容
template<class T1, class T2>
返回值类型 函数名(Base<T1, T2>B){ 具体实现 }
//类的定义，将全局函数作为友元
template<class T1, class T2>
class Base{
    friend 返回值类型 函数名<>(Base<T1, T2> B);//加空模板参数列表，表明友元是一个函数模板实现
}

2 STL基础概念

C++的面向对象和泛型编程的思想，目的就是复用性的提升。

大多数情况数据结构和算法都未能有一套标准，被迫从事大量重复工作；为了建立数据结构和算法的一套标准，诞生了STL

2.1 STL的概念

STL(Standard Template Library,标准模板库)

• STL从广义上分为：容器(container)、算法(algorithm)、迭代器(iterator)
• 容器和算法之间使用迭代器进行无缝连接
• STL中几乎所有的代码都使用了模板类或模板函数

2.2 STL六大组件

容器、算法、迭代器、仿函数、适配器(配接器)、空间配置器

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

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

容器：置物之所也

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

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

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

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

算法：问题之解也

使用有限的步骤，解决逻辑或数学上的问题，这一门学科称作算法(Algorithm)

算法分为质变算法和非质变算法：

• 质变算法：运算过程中会更改区间内的元素的内容，如拷贝、替换、删除等
• 非质变算法：运算过程中不会更改区间内元素的内容，如查找、计数、遍历、寻找极值等

迭代器：容器与算法之间的粘合剂

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

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

迭代器的使用类似于指针，在初学阶段可以暂时将迭代器理解为指针

迭代器种类：

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

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

2.4 容器算法迭代器——以vector为例

2.4.1 vector存放内置数据类型

容器：vector vector不是一种数据类型，而只是一个类模板，可用来定义任意多种数据类型。vector类型的每一种都指定了其保存元素的类型。因此，vector< int>和vector < string>都是数据类型。

算法：for_each（遍历，需要#inlcude < algorithm>）

迭代器： vector< 内置数据类型 >::iterator 变量名 定义了一个变量，它的数据类型是由vector<内置数据类型>定义的iterator类型。每个容器都定义了一种名为iterator的类型，而这种类型支持（概念上的）迭代器的各种行为。

vector<int> v;
//迭代方式1
vector<int>::iterator itBegin  = v.begin();//起始迭代器，指向容器中第一个元素
vector<int>::iterator itEnd = v.end();
//结束迭代器，指向容器中最后一个元素的下一个位置
//由end操作返回的迭代器并不指向vector中任何实际的元素，
//相反，它只是起一个哨兵(sentinel)的作用，表示我们已处理完vector中所有元素。
while(itBegin != itEnd){
    cout<<*itBegin<<endl;
    itBegin++;
}
//迭代方式2
for(vector<int>::iterator it = v.begin(); it != v.end(); it++){
    cout<<*it<<endl;
}
//迭代方式3 利用STL提供的遍历算法，for_each的第三个形参为迭代时对数据元素进行操作的函数
void myprint(int val){
    cout<<val<<endl;
}
for_each(v.begin(), v.end(), myprint); 

2.4.2 vector存放自定义数据类型

基本使用方式和内置数据类型相同；需要注意的是存放自定义类的数据类型时<>内数据类型的填写。

2.4.3 vector容器嵌套容器

vector <vector<数据类型> > 容器名;

在调用时需要注意实际上所存储的内容

vector< vector<int> > v;
//对此容器进行迭代输出，大容器v中存放的是一个个小容器，小容器才存储最小单位的数据元素
for(vector<vector<int>>::iterator it = v.begin;it != v.end(); it++){
    // *it ——容器vector<int>
    for(vector<int>::iterator vit = (*it).begin(); vit!=(*it).end();vit++){
        // *vit ——容器vecotr<int>所存的数据元素
        cout<<*vit<<endl;
    }
}