C++标准库简要学习 (草稿)

    C++以库的形式提供了大量的函数和类供程序员使用，除了C语言继承而来的库，也给予了基于面向对象的许多类，统称C++标准库。C++标准库不是C++本身的内容，而是C++语言的扩展，C++标准库的代码较为精炼但是功能却很强大是通过模板技术实现的，所谓模板技术，是一种代码重用技术，针对C++当中实现代码重用的函数和类两种技术机制，使得函数和类的代码更加凝练。由于大量使用模板技术,C++标准库有时也成为标准模板库，即STL库。

 

    模板技术首先要求程序员编写代码模板，编译器根据模板自动生成代码实例实现。

 

我们先了解函数模板和类模板，再了解C++标准库。

 

 

10.1函数模板

定义：通过数据类型的参数化，将一组算法相同但是数据类型不同的重载函数凝练成一个模板，编译时，编译器按照函数模板针对不同的数据类型自动生成针对各自数据类型的重载函数。

 

语法：

template <l类型参数列表>

函数类型 函数名(形参列表)

{

 函数体

}

 

注意点：

1. 定义函数模板以template关键字，类型参数表里可以有一到多个类型参数，均以”typename 类型参数名”或者”class 类型参数名”的形式来定义，类型参数之间以”,”隔开，函数类型参数的命名规则同标识符命名规则。

2. 函数模板的其他部分与普通函数没有区别，唯一注意的是类型参数可以出现在任何数据类型可以出现的地方。

3. 函数模板定义的前两行称为函数模板头。若函数模板调用在定义之前，需要声明函数模板头，可以写成两行或者一行。

 

定义好了一个函数模板，就可以直接调用了。

 

例子：

#include <iostream>
using namespace std;

template <typename T>
T max(T A, T B) {
    return (A > B?A:B);
}

int main(){
    cout << max(8.8, 6.3) << endl;
    cout << max('a', 'c');
    return 0;
}

 

那么为什么函数模板定义以后可以直接调用？

答：C++编译器在编译到函数模板调用语句时，编译器将根据参数推导类型参数T的类型，然后自动生成相应的函数实例，并调用该函数，多次调用函数模板本质是生产重载函数，实际编译出的可执行代码不变，执行效率也不变，只是减少了程序员的工作量。

 

 

10.2类模板

定义：应用模板技术，将一组功能相同但是处理数据类型不同的类凝练成一个类模板，编译时再由编译器按照类模板自动生成针对不同数据类型的类定义代码。

 

语法：与函数模板相似：

template<类型参数表>

class 类名{

类成员声明

}

//下面是成员函数类外实现部分

template 类名<类型参数表>

函数类型 类名<类型参数表>::函数名(形参表){

函数体

}

 

语法：主要是成员函数类外实现比较麻烦，一般是在函数名前加类名限定，这里不仅要加templa语句，下面的类名也要带上类型参数，类型参数得写两遍。

 

使用类模板: 定义好了一个类模板时，就可以利用类模板来直接定义一个对象了：

 类模板名<实际类型参数表>对象名1(构造函数所需的实参列表1)，对象名2(构造函数所需的实参列表2).......

其基本原理也是编译器根据实参猜测类型参数的实际类型，对类模板实例化，生成实例类，再利用类模板生成所需的对象，然后就可以正常利用对象名访问其数据成员和成员函数了。

我们也可以不用编译器猜测，直接指定类模板里类型参数的具体类型，即：使用typedef显式地实例化类模板，如下代码所示：

typedef A<double> DoubleA；  //生成一个类型参数T为double的实例类，名为DoubleA
DoubleA o1(10.5,6);  //正常地实例化出一个对象
o1.show(); //正常地调用其方法。

 

typedef A<int> IntA；  //生成一个类型参数T为int的实例类，名为IntA
Int A o1(10.5,6);  //正常地实例化出一个对象
o1.show(); //正常地调用其方法

 

类模板也可以被继承，派生出新类，可以在派生过程中实例化，也可以继续派生为模板，细节就不展开了。

 

 

10.5数据集合与处理算法

1.数据集合：数据项→数据元素→数据集合 数据项是单独的数字或字符串 数据元素则是一条一条的记录，数据集合则是表格形式。

 

2.算法：对数据集合的处理：增删改查、排序。

 

研究数据集合的存储与操作的知识分别称为数据结构与算法

 

C++标准库为数据集合提供了基本的数据集合提供了基本的数据结构类和常用算法。

 

 

我们可以定义结构体或者类，利用数组或者链表来存储数据集合。链表不同于数组，每次只有一个元素通过动态分配内存的方法获得存储空间。

 

#include <iostream>
using namespace std;

typedef struct Student{
char name[10];
float score;
}Stu;   //一起活动的数值可以做成结构体比较好

 
int main() {
Stu s[3];
strcpy_s(s[0].name, "aa"); s[0].score = 92;    //结构体进数组是先开数组，再对其各个元素赋值实现的
strcpy_s(s[1].name, "bb"); s[1].score = 99;
strcpy_s(s[2].name, "cc"); s[2].score = 85;

Student* p = s;

for (int i = 0; i < 3; i++){
    cout << p->name << "," << p->score << endl;
    p++;  //结构体的指针类似迭代器
}
return 0;
}

 

链表中的数据元素称为结点，结点各自独立分配内存，所分配的内存单元分散在不同单元并不连续，为了表现结点的先后次序，每个结点除了数据元素的内容外需要增加指向前一个或者后一个的指针变量。

 

链表的第一个结点称为首结点，最后一个结点称为尾结点，同时具有前向和后向指针的链表称为双向链表，只有一个方向的链表称为单向链表。

 

 

链表的逻辑实现： //非面向对象思想完成

1. 制作数据元素的一个指针，这个指针要一直指向首元素，定位begin

2. New一个数据元素的实体，用begin指针指向它，它要承载首结点的内容

3. 通过begin->,利用strcpy为其中的字符串变量赋值，其他的直接赋值

4. 前向指针置0，后置指针也置0，第一个结点的工作

5. 为了第n个结点的前置结点可以指向前面第n-1个节点，我们要保留当前结点的位置，再做一个指针curNode，用begin初始化它。这个任务现在还不迫切，但是第二个节点定完以后必须要做。

6. 再定义一个指针p，动态分配内存，内容初始化，前向指针要指向curNode（或者begin）去初始化它，后置依然置0，保留当前指针的位置curNode=p;

7. 第三个节点就不再需要重新定义指针p了，直接动态分配内存，初始化，直到终结。

 

 

For循环遍历整个链表：

链表不像数组知道具体的个数，所以要用while循环，首先用begin更新curNode，当curNode为0时跳出循环，循环体内利用curNode指针访问节点的元素，访问完后，利用后向指针更新curNode（假设3个节点的链表，第二个节点访问结束，curNode改变，访问完第三个，curNode置0，判读为false，跳出循环）

 

 

链表的特点：便于插入删除，但只能顺序访问，而且存储的内较多。

#include <iostream>
using namespace std;

typedef struct Student{
char name[10];
float score;
struct Student* p_pre;
struct Student* p_nex;
}Stu;   //一起活动的数值可以做成结构体比较好

int main() {
Student* begin;
begin = new Student;
strcpy(begin->name, "aa"); begin->score = 92;
begin->p_nex = 0; begin->p_nex = 0;
Student* curNode = begin;

Student* p = new Student;
strcpy(p->name, "bb"); p->score = 85;;
p->p_pre = curNode; p->p_nex = 0;  //若前面是stu后面就报错了
curNode = p;

 p = new Student;
strcpy(p->name, "cc"); p->score = 87;;
p->p_pre = curNode; p->p_nex = 0;  //若前面是stu后面就报错了
curNode = p;


curNode = begin;
while (curNode != 0) {
cout << curNode->name << "," << curNode->score << endl;
curNode = curNode->p_nex;

}
return 0;
}

C++标准库当中数据集合的存储和处理：
为了存储数据集合，C++标准库提供了7个数据结构类，它们统称为容器类。

迭代器：不同数据结构里的元素数据结构是不同的，（例如单纯数组，链表的结点，vector下经过封装的数组等等），为了逐个逐个访问它们，我们有了迭代器这个类，可以拿出单个数据元素。它们类似于指针。

为了处理容器当中的数据集合，C++标准库提供了接近70个左右的函数，它们都在<algorithm>头文件里，它们接受迭代器作为形参，进行相应的处理。为了接受不同类型的迭代器，C++将这些算法都定义成了模板，算法函数就可以处理不同类型的数据结构了。

 

 

迭代器是容器与算法的桥梁，容器装内容，。对于不同的容器而言，需要各自的迭代器来访问，迭代器一个一个拿出来，算法一个通吃所有，对于各种类型的迭代器都一个套路来处理。迭代器主要有输入迭代器，输出迭代器，输入迭代器，双向迭代器，前向迭代器，类比指针的p++,p--,p->,p[],*p，

输入迭代器只能读不能改值，不能后退，

输出迭代器，只能改不能读，不能后退

前向迭代器是多继承了前两者，能读能改，但是不能后退

双向迭代器，可以p++，还可以p--，前后移动

随机访问迭代器，不仅有++，--，还有p[],可以跳转，而且还有>,>=,<,<=,+,-运算，具体的功能我还不知道。

 

 

 

 

1. C++标准库的容器类

为了存储数据的C++提供了7个数据结构类，它们统称容器类，主要有

向量类:vector 列表类:list 集合类:set 映射类:map

单个数据元素进入这些类，就像进入数组一样，当然适配不同的数据元素(好多是结构体和对象)，所以它们都做成了类模板，底层是数组或者链表，作为数据成员，并且封装了一些相关的方法。

 

向量类：

vector 存储一维有序的数据类型的类模板 使用时需要包含<vector>

特点：

1.内部存储类型是数组，所有元素都是一个类型的。

2.存储的元素不受限制，元素个数超过存储容量时会自动扩展

3.迭代器是随机访问迭代器，可以按下标访问元素

 

使用方法：

函数	作用
vector<class T> v;	定义了一个存储的数据元素的类型是T类型的空向量
vector<class T> v(n);	定义了一个初始元素个数为n的向量，他们基本内容是空白
vector<class T>::iterator it;	定义了一个vector的迭代器对象，为随机访问迭代器
v.begin()	返回第一个元素的迭代器
v.end()	返回最后一个元素后面那个空元素的迭代器(方便for循环)
v.size()	返回向量中元素的个数
v.push_back(e)	在向量末尾添加一个元素,e的类型为T
v.pop_back	删除向量当中最后一个元素
v.insert(it,e)	在it位置的元素之前插入一个元素e，it是一个迭代器v.insert(it,e)
v.erase(it)	删除it所指向的元素，返回指向其下一个元素的迭代器
v.clear()	删除向量中的所有元素

#include <iostream>
#include <vector>
using namespace std;

typedef struct Stu {
char name[10];
int score;
}Student;

int main() {

vector<Student> qq(3);   //做好vector 前三个是空对象
vector<Student>::iterator vit;   //做好vector的迭代器

 
Student*p = new Student;
strcpy_s(p->name, "aa");
p->score = 80;                //做好了一个结构体

 
qq.push_back(*p);                  //送进去了

cout << qq.size() << endl;        //size方法

vit = qq.begin()+3;                 //访问第四个

cout << vit->name << endl;       

Student*pp = new Student;
strcpy_s(pp->name, "bb");
pp->score = 60;
vit = qq.begin() + 1;  //下标是要以迭代器实现的
qq.insert(vit, *pp);    //看我插到下标一的位置上去
cout << "----------------------" << endl;

for ( vit=qq.begin(); vit!=qq.end(); vit++){
cout << vit->name <<"   ";
}

cout << endl;
qq.pop_back();

cout << "----------------------" << endl;
for (vit = qq.begin(); vit != qq.end(); vit++){
cout << vit->name << "   ";
}
return 0;
}

 

 

下面是利用sort函数进行排序的例子：

#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;

typedef struct Stu {
char name[10];
int score;
}Student;

 

bool comp(Student a, Student b) {
bool k = true;
if (a.score > b.score) {
k = false;
}

if (a.score == b.score) {
    if (strcmp(a.name,b.name)) {
        k = false;
        }
else {
    k = true;
    }
}
return k;
}

int main() {
vector<Student> qq;
vector<Student>::iterator vit;
 
Student s;
s = { "aa",20 };    //结构体字符串赋值方法 整体赋值
qq.push_back(s);

Student *ss = new Student;
strcpy_s(ss->name, "bb");     //结构体的字符串赋值方法二 strcpy
ss->score = 80;
qq.push_back(*ss);

s = { "cc",60 };
qq.push_back(s);

s = { "dd",60 };    //结构体字符串赋值方法 整体赋值
qq.push_back(s);

sort(qq.begin(), qq.end(), comp);
for (vit = qq.begin(); vit != qq.end(); vit++)
{
    cout << vit->name << " " << vit->score << endl;
}
return 0;
}

 

 

列表类list 存储一维有序数据序列  需包含<list>类声明头文件

与vector的区别是：

1. 内部存储空间是链表，每个元素的空间并不相邻，更加适合频繁增删

2. 其迭代器是双向迭代器而非vector是随机访问迭代器，所以不支持下表访问

 

也是利用push_back在最后一个位置上添上新元素，不过新增了push_front，可以在最前面放元素，细节以后再看

 

 

集合类set  存储一维无序数据序列  需包含<set>类声明头文件

特点：

1. 插入的元素会被按照某种键值自动排序

2. 可以通过表函数来指定排序键值？？？？

3. 集合中每个元素都是唯一的，不能重复，重复的元素会被自动丢弃

4. 集合的迭代器是双向迭代器。

插入的操作为 insert(T)

 

映射类 map 存储“键-值”类型数据的容器类 需包含<map>类声明头文件

特点：

1. 向映射当中插入元素，键自动排序，方便以后快速查找

2. 插入的每个元素键应该是唯一的，若插入键重复的元素，新元素将覆盖老元素

3. 迭代器是双向迭代器

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
map<string, int>sim;
sim["zhang san"] = 92;
sim["li si"] = 88;   //简单插入法
sim.insert(map<string, int>::value_type("wangwu", 75)); //复杂插入法1
sim.insert(pair<string, int>("pipi", 44));   //复杂插入法2
sim["li si"] = 100;   //简单插入法有同键覆盖的特点

sim.insert(pair<string, int>("li si", 44));   //复杂插入法遇到键相同，就不发生作用

map<string, int>::iterator vit;

for (vit = sim.begin(); vit != sim.end(); vit++) {
    cout << vit->first << "," << vit->second << endl;
}
return 0；
}