c++核心编程第一部分讲义_耗时一周，一万字总结C++提高编程二STL第一部分，确定不点个收藏-CSDN博客

1，STL初识

1.1 目的

为了创建一种可重复利用的东西，C++中的面向对象和泛型编程思想，就是复用性的提升

STL是为了建立数据库和算法的一套标准

1.2 基本概念

STL:标准模板库
STL从广义上分为：容器，算法，迭代器
容器和算法之间通过迭代器进行无缝连接
STL几乎所有的代码都采用了模板类或者模板函数

1.3 STL六大组件

STL分为六大组件：容器，算法，迭代器，仿函数，适配器(配接器)，空间配置器

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

1.4 STL中的容器，算法，迭代器

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

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

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

算法：用有限的步骤解决逻辑上或者数学上的问题

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

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

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

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

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

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

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

1.5容器算法迭代器初始

STL中最常用的容器为vector，可以理解为数组

1.5.1vector存放内存数据类型

容器：vector

算法：for_each

迭代器：vector::intertor

#includeusing namespace std;#include#includevoid show(int a){cout << a << endl;}void Test(){//使用vector容器对象，并且通过模板参数指定容器中存放的数据的类型vector a;//向容器中放数据a.push_back(10);a.push_back(20);a.push_back(30);a.push_back(40);a.push_back(50);//每一个容器中都有自己的迭代器//a.begin()返回迭代器，这个迭代器指向容器中的第一个数据//a.end()返回迭代器，这个迭代器指向容器中的最后一个元素的下一个位置//vector::iterator 拿到vector这种容器的迭代类型vector::iterator P_begin = a.begin();vector::iterator P_end = a.end();//第一种遍历方式while (P_begin != P_end){cout << *P_begin << endl;P_begin++;}//第二种遍历方式for (vector::iterator i = P_begin; i != P_end; i++){cout << *i;}//第三种遍历方式//使用STL的遍历算法，头文件：algorithmfor_each(P_begin, P_end, show);}int main(){Test();system("pause");return 0;}

1.5.2 Vector存放自定义数据类型

将数据类型变为自定义的，比如类和其他的自己定义出来的东西

#includeusing namespace std;#include#includeclass Person{public:Person(int a, int b){this->a = a;this->b = b;}int a;int b;};void show(int a){cout << a << endl;}void Test(){Person p1(10, 20);Person p2(10, 20);Person p3(10, 20);Person p4(10, 20);Person p5(10, 20);vector a;//向容器中放数据a.push_back(p1);a.push_back(p2);a.push_back(p3);a.push_back(p4);a.push_back(p5);for (vector::iterator i = a.begin(); i != a.end(); i++){cout << (*i).a << "    " << (*i).b << endl;}}void Test1(){Person p1(10, 20);Person p2(10, 20);Person p3(10, 20);Person p4(10, 20);Person p5(10, 20);vector a;//向容器中放数据a.push_back(&p1);a.push_back(&p2);a.push_back(&p3);a.push_back(&p4);a.push_back(&p5);for (vector::iterator i = a.begin(); i != a.end(); i++){cout << (*i)->a << "    " << (*i)->b << endl;}}int main(){Test();Test1();system("pause");return 0;}

1.5.3 Vector容器嵌套容器

一个数组中嵌套一个小数组，类似于二维数组

#includeusing namespace std;#include#includevoid Test(){vector> a;vector a1;vector a2;vector a3;vector a4;vector a5;for (int i = 0; i < 4; i++){//向容器中放数据a1.push_back(i+1);a2.push_back(i+2);a3.push_back(i+3);a4.push_back(i+4);a5.push_back(i+5);}a.push_back(a1);a.push_back(a2);a.push_back(a3);a.push_back(a4);a.push_back(a5);    //通过大容器，把所有数据遍历一遍for (vector>::iterator i = a.begin(); i != a.end(); i++){        //(*)it————容器vectorfor (vector::iterator j = (*i).begin(); j != (*i).end(); j++){cout << *j <

2，STL常用容器

注：下面几乎全部都是套用模板，所以有些地方未展示代码，都可以根据模板自己尝试

2.1string容器

2.1.1string基本概念

本质：

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

string和char*的区别：

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

特点：

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

2.1.2string构造函数

string(); //创建一个空的字符串

string s1;

string(const char *s); //使用字符串s初始化

const char *a = "hello world"; string s2(a);

string(const string &str); //使用一个string对象初始化另一个string对象

string s3(a);

string(int n,char c); //使用n个字符c初始化

string s4(5, 'a');

2.1.3string赋值操作

功能：

给string类型字符串进行赋值

赋值的函数原型：

string& operator=(const char*s); //char*类型字符串，赋值给当前的字符串

string s1=("hello world");

string& operator=(const string*s); //把字符串s赋值给当前的字符串

string s2=a;

string& operator=(char c); //字符赋值给当前的字符串

string s3 = ("h");

string& assign(const char*s); //把字符串s赋值给当前的字符串

s4.assign(a);

string& assign(const char*s,int n); //把字符串s的前n个字符赋给当前的字符串

s5.append("hello world", 5);

string& assign(const string*s); //把字符串s赋给当前字符串

string s6;

s6.assign("hello world");

string& assign(int n,const c); //用n个字符c赋值给当前字符串

string s7(5, 'a');

2.1.4string字符串拼接

功能：

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

函数原型：

string& operator+=(const char* str); //重载+=操作符

s1 += "hello";

string& operator+=(const char c); //重载+=操作符

s1 += ',';

string& operator+=(const string& str); //重载+=操作符

s1 += s2;

string& append(const char* s); //把字符串s连接到当前字符后才能结尾

s3.append("am");

string& append(const char* s,int n); //把字符串s的前n个字符连接到当前字符串结尾

s3.append("abcdef", 4);

string& append(const string &s); //同operator+=(const string& str);

s3.append(s2);

string& append(const string &s,int pos,int n); //字符串s中从pos开始的n个字符连接到字符串结尾

s3.append(s2, 0, 4);

2.1.5string查找和替换

功能描述：

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

函数原型：

int find(const string& str,int pos=0) const; //查找str第一次出现位置，从pos开始查找
int find(const char* str,int pos=0) const; //查找s第一次出现位置，从pos开始查找

const char *a1 = "wo"; string a2 = "hello world"; int b = a2.find(a1);

int find(const char*s, int pos,int n) const; //从pos位置查找s的前n个字符第一次位置

int b = a2.find(a1, 2, 1);

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开始查找

const char *a1 = "wo"; string a2 = "hello worldwo"; int b = a2.rfind(a1);

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 a2 = "hello world"; a2.replace(1, 3, "aaaaa");

string& replace(int pos,int n,const char *s) ; //替换从pos开始的n个字符为字符串s

总结：

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

2.1.6string字符串比较

功能介绍：

字符之间进行比较

比较方式：

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

= 返回 0
> 返回 1
< 返回 -1

函数原型：

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

#includeusing namespace std;#includeint main(){string a = "hello";string b = "hello";if (a.compare(b) == 0){cout << "a与b相等" << endl;}else if (a.compare(b) == 1){cout << "a大于b" << endl;}else{cout << "a小于b" << endl;}system("pause");return 0;}

总结：主要目的是判断是否相等，并不是判断谁大谁小

2.1.7 string字符存取

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

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

#includeusing namespace std;#includeint main(){string a = "hello";for (int i = 0; i < a.size(); i++){cout << a[i] << "  " << a.at(i) << endl;}a[0] = 'a';cout << a << endl;a.at(1) = 'a';cout << a << endl;system("pause");return 0;}

总结：利用“[ ]”和“at()”；

2.1.8string插入和删除

功能描述：

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

函数原型：

string &insert(int pos,const char*s); //插入字符串

string a = "hello"; a.insert(1, "aaa");

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

a.erase(1, 3);

2.1.9string子串

功能描述：

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

函数原型：

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

string a = "helloasdq"; string b = a.substr(2, 5);

2.2vector容器

2.2.1 vector基本概念

功能：

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

vector与普通数组区别：

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

动态扩展：

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

2.2.2vector构造函数

功能描述：

创建vector容器

函数原型：

vector v; //采用模板实现类实现，默认构造函数

vector a; for (int i = 0; i < 10; i++) { a.push_back(i); }

vector(v.begin(),v.end()); //将v[begin(),end()]区间中的元素拷贝给本身

vectorb(a.begin(), a.end());

vector(n,elem); //构造函数将n个elem拷贝给本身

vectorc(10, 100);

vector(const vector &vec); //拷贝构造函数

vectord(c);

2.2.3vector赋值操作

功能描述：

给vector容器进行赋值

函数原型：

vector &operator=(const vector &vec); //重载等号操作符

vectorb; b.assign(a.begin(), a.end());

assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给本身

vectorc; c = a;

assign(n,elem); //将n个elem拷贝赋值给本身

vectord; d.assign(10, 100);

2.2.4vector容量和大小

功能描述：

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

函数原型：

empty(); //判断容器是否为空

if (a.empty()) { cout << "容器为空" << endl; }

capacity(); //容器的容量

cout << a.capacity() << endl;

size(); //返回容器中元素的个数

cout << a.size() << endl;

resize(int num); //重新指定元素的长度为num，若容器变长，则以默认值填充新位置，如果变短，则超出部分删除

a.resize(5);

resize(int num,elem); //重新指定容器长度，如果边长，则用elem填充，如果变短，则超出部分删除

a.resize(3, 10);

2.2.5vector插入和删除

功能描述：

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

函数原型：

push_back(ele); //尾部插入元素ele

vector a; for (int i = 0; i < 10; i++) { a.push_back(i); }

pop_back(); //删除最后一个元素

a.pop_back();

insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele

a.insert(a.begin(), 100);

insert(const_iterator pos,int count,ele); //迭代器指向位置pos插入count个元素ele

a.insert(a.begin(), 3, 100);

erase(const_iterator pos); //删除迭代器指向的元素

a.erase(a.begin());

erase(const_iterator start,const_iterator end); //删除迭代器从start到end之间的元素

a.erase(a.begin(), a.end());

clear(); //删除容器中所有的元素

a.clear();

2.2.6vector数据存取

功能描述：

对vector中的数据的存取操作

函数原型：

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

cout << a[1]; cout << a.at(1); cout << a.front(); cout << a.back();

2.2.7vector互换容器

功能描述：

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

函数原型：

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

b.swap(a); vector(a).swap(a); //当容量过大，但是数据很少时，可以用这种方法收缩内存 (通过匿名对象)

2.2.8预留空间

功能描述：

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

函数原型：

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

2.3deque容器

2.3.1deque容器基本概念

功能：

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

deque和vector区别：

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

deque内部工作原理：

中控器用来维护每段缓冲区中的内容，缓冲区中存放真实数据，如果一个缓冲区数据存满之后，则在中控器中开辟新的一块，维护新的一段缓冲器来保存数据。中控器中维护的是每个缓冲区的地址，使得使用deque时，像一片连续的内存空间

deque使用了两个迭代器M_start和M_finish，对首个deque块和末deque块进行控制访问。迭代器iterator共有4个变量域，包括M_first、M_last、M_cur和M_node。M_node存放当前deque块的Map数据项地址，M_first和M_last分别存放该deque块的首尾元素的地址(M_last实际存放的是deque块的末尾字节的地址)，M_cur则存放当前访问的deque双端队列的元素地址。

2.3.2deque构造函数

功能描述：

deque容器构造

函数原型：

deque deqT; //默认构造函数

deque a; for (int i = 0; i < 5; i++) { a.push_back(i); }

deque(beg,end); //构造函数将[beg，end]区间中的元素拷贝给本身

dequeb(a.begin(),a.end());

deque(n,len); //构造函数将n个elem拷贝给本身

dequec(10, 100);

deque(const deque &deq); //拷贝构造函数

dequed(c);

2.3.3deque赋值操作

功能描述：

给deque容器进行赋值

函数原型：

deque operator=(const deque &deq); //重载等号运算符

dequed; d=a;

assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给本身

b.assign(a.begin(), a.end());

assign(n,elem); //将n个elem拷贝赋值给本身

c.assign(10, 100);

2.3.4deque大小操作

功能描述：

对deque容器的大小进行操作

函数原型：(直接套用模板，没有展示代码部分)

deque.empty(); //判断是否为空
deque.size(); //返回容器中的个数
deque.resize(num); //重新指定个数，容器变长则填充默认值，容器变短，则超出部分删除
deque.resize(num,elem); //重新制定个数，容器变长则用elem填充，容器变短，则超出部分删除
deque中没有容量的概念

2.3.5deque插入和删除

功能描述：

向deque容器中插入和删除数据

函数原型：(代码实现直接套用模板)

两端插入操作：

push_back(elem);
push_front(elem);
pop_back();
pop_front();

指定位置操作：

insert(pop,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值

a.insert(a.begin(),10); a.insert(a.begin(), 5, 100);

insert(pop,beg,end); //在pos位置插入[beg，end]区间的数据，无返回值
clear(); //清空所有数据
erase(beg,end); //删除[beg,end]区间的数据，返回下一个数据的位置
erase(pos); /删除pos位置的数据，返回下一数据的位置

a.erase(a.begin() + 7);

插入删除提供的位置都是迭代器

2.3.6deque数据存储

功能描述：

对deque中的数据的存取操作

函数原型：(代码实现直接套用模板)

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

2.3.7deque排序

功能描述：

利用算法实现对deque容器进行排序

算法：

sort(iterator beg,iterator end); //对beg和end区间内数据进行排序

#includeusing namespace std;#include#include    //标准算法头文件void show(const deque&a){for (deque::const_iterator i = a.begin(); i != a.end(); i++){cout << *i << " ";}cout << endl;}int main(){deque a;for (int i = 0; i < 5; i++){a.push_back(i);}for (int i = 5; i < 10; i++){a.push_front(i);}show(a);sort(a.begin(),a.end());show(a);system("pause");return 0;}

注：

默认排序为从小到大排序
需要包含头文件：#include //标准算法头文件

2.4stack容器

2.4.1stack的基本概念

概念：stack是一种先进后出的数据结构，它只有一个出口

栈中只有栈顶的元素才可以被外界使用，因此栈中不允许有遍历行为

栈中进入数据称为——入栈 push
栈中弹出数据称为——出栈 pop

2.4.2stack常用接口

功能描述：

栈容器常用的对外接口

构造函数：

stack stk; //stack采用模板类实现，stack对象的默认构造形式

stack a;

stack(const stack &stk); //拷贝构造函数

赋值操作：

stack operator=(const stack &stk) //重载等号操作符

数据存取：

push(elem); //向栈顶添加元素
pop(); //从栈顶移除第一个元素
top(); //返回栈顶元素

大小操作：

empty(); //判断堆栈是否为空
size(); //返回栈的大小

stack a; for (int i = 0; i < 5; i++) { a.push(i); } stack b(a); stackc; c= a; while (!a.empty()) { cout << a.top() << endl; a.pop(); }

2.5queue容器

2.5.1queue基本概念

概念：queue是一种先进先出的数据结构，他有两个出口

队列容器允许从队尾新增数据，从队头移除数据，只有队头和队尾才能被外界使用，所以不允许有遍历行为

队列中进数据称为——入队 push
队列中出数据称为——出队 pop

2.5.2quene常用接口

功能描述：

队列容器常用的对外接口

构造函数：

quene que; //quene采用模板类实现，quene对象的默认构造形式
quene(const quene &que); //拷贝构造函数

赋值操作：

quene operator=(const quene &stk) //重载等号操作符

数据存取：

push(elem); //向队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素

cout << a.front() << " " << a.back() << endl;

大小操作：

empty(); //判断容器是否为空
size(); //返回容器的大小

2.6 list容器

2.6.1 list基本概念

功能：将数据进行链式存储

链表是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链表实现的

链表的组成：链表由一系列结点组成

结点的组成：一个是存储数据单元的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是一个双向循环链表

由于链表的存储方式并不是连续的内存地址，因此链表list中的迭代器只支持前移和后移，属于双向迭代器

list的优点：

采用动态存储分配，不会造成内存浪费和溢出
链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素

list的缺点：

链表灵活，但是空间(指针域)和时间(遍历)额外消耗较大

list在插入操作和删除操作都不会造成原有list迭代器失效，这在vector是不成立的

2.6.2 list构造函数

功能描述：

创建list容器

函数原型：

list lst; //list采用采用模板类实现，对象的默认构造形式
list(beg,end); //构造函数将(beg ,end)区间中的元素拷贝给本身
list(n,elem); //构造函数将n个elem拷贝给本身
list(const list&lst); //拷贝构造函数

2.6.3list赋值和交换

功能描述：

给list容器进行赋值，以及交换list容器

函数原型：

assign(beg,end); //将[beg,end]区间中的数据拷贝赋值给本身
assign(n,elem); //将n个elem拷贝赋值给本身
list& operator=(const list &lst); //重载等号操作符
swap(lst); //将list与本身的元素互换

2.6.4 list大小操作

功能描述：

对list容器的大小进行操作

函数原型：(直接套用模板，没有展示代码部分)

empty(); //判断是否为空
size(); //返回容器中的个数
resize(num); //重新指定个数，容器变长则填充默认值，容器变短，则超出部分删除
resize(num,elem); //重新制定个数，容器变长则用elem填充，容器变短，则超出部分删除

2.6.5list插入和删除

功能描述：

向list容器中进行数据插入和删除

函数原型：(代码实现直接套用模板)

两端插入操作：

push_back(elem); //在容器尾部加一个元素
push_front(elem); //在容器开头插入一个元素
pop_back(); //删除容器最后一个元素
pop_front(); //从容器开头移除第一个元素
insert(pop,elem); //在pos位置插入一个elem元素的拷贝，返回新数据的位置
insert(pos,n,elem); //在pos位置插入n个elem数据，无返回值
insert(pop,beg,end); //在pos位置插入[beg，end]区间的数据，无返回值
clear(); //清空所有数据
erase(beg,end); //删除[beg,end]区间的数据，返回下一个数据的位置
erase(pos); /删除pos位置的数据，返回下一数据的位置
remove(elem); //删除容器中所有与elem值匹配的元素

2.6.6 list数据存取

功能描述：

对list容器中数据进行存取

函数原型：

front(); //返回第一个元素
back(); //返回最后一个元素

#includeusing namespace std;#include#include    //标准算法头文件int main(){list a;for (int i = 0; i < 5; i++){a.push_back(i);}list b(a);while (!a.empty()){cout << a.front() << "  " << a.back() << endl;a.pop_back();}b.erase(b.begin());cout << b.front() << endl;b.remove(3);system("pause");return 0;}

2.6.7 list反转与排序

功能描述：

将容器中的元素反转，以及将容器中的数据进行排序

函数原型：

reverse(); //反转链表
sort(); //链表排序(从小到大)

#includeusing namespace std;#include#include    //标准算法头文件int main(){list a;a.push_front(40);a.push_front(20);a.push_front(30);a.push_front(10);a.push_front(90);a.push_front(60);listb;b = a;listc(b);while (!a.empty()){cout << a.front()<