目录
概述
为了建立数据结构和算法的一套标准，并且降低他们之间的耦合关系，以提升各自的独立性、弹性、交互操作性(相互合作性,interoperability),诞生了STL。
STL就是把数据结构和算法的代码制定了标准代码，其他人直接使用就可以了
数据结构和算法：
数据结构的含义：研究的是数据和数据之间的关系
数据结构的概念：数据结构指的是数据的逻辑结构、存储结构以及操作
逻辑结构：
一对一的关系：线性表、栈（先进后出）、队列（先进先出）
一对多的关系：树、二叉树
多对多：图
存储结构：
顺序存储：需要开辟一块连续的空间
链式存储：不需要开辟连续的空间
操作：
增、删、改、查
例如：
单链表：线性表的链式存储
算法：实现功能的方法
STL(Standard Template Library,标准模板库)，是惠普实验室开发的一系列软件的统
称。现在主要出现在 c++中，但是在引入 c++之前该技术已经存在很长时间了。
STL 从广义上分为: 容器(container) 算法(algorithm) 迭代器(iterator),容器和算法之间通过迭代器进
行无缝连接。STL 几乎所有的代码都采用了模板类或者模板函数，这相比传统的由函数和类组成的库来说提供了更好的代码重用机会。STL(Standard Template Library)标准模板库,在我们 c++标准程序库中隶属于 STL 的占到了 80%以上。
STL的六大组件
STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器。
容器：
各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容
器是一种类模板
算法：
各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种函数模板
迭代器：
扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* ,
operator-> , operator++,operator--等指针相关操作予以重载的class template.
所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。
原生指针(nativepointer)也是一种迭代器。
仿函数：
行为类似函数，可作为算法的某种策略。
从实现角度来看，仿函数是一种重载了operator()的class 或者class template
仿函数本质是一个类，类中有运算符()的重载函数
适配器：
一种用来修饰容器或者仿函数或迭代器接口的东西。
空间配置器：
负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、
空间释放的class tempalte.
STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内
容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数。
STL最重要的三大组件
容器
STL容器就是将运用最广泛的一些数据结构实现出来。
常用的数据结构：数组(array),链表(list),tree(树)，栈(stack),队列(queue),集合(set),映射表(map),根据数据在容器中的排列特性，这些数据分为序列式容器和关联式容器两种。
序列式容器强调值的排序，序列式容器中的每个元素均有固定的位置，除非用删除或插入的操作改变这个位置。Vector容器、Deque容器、List容器等，序列式容器中的数据不需要有序
关联式容器是非线性的树结构，更准确的说是二叉树结构。各元素之间没有严格的物理上的顺序关系，也就是说元素在容器中并没有保存元素置入容器时的逻辑顺序。关联式容器另一个显著特点是：在值中选择一个值作为关键字key，这个关键字对值起到索引的作用，方便查找。Set/multiset容器Map/multimap容器，关联式容器的数据必须是有序的
算法
算法，问题之解法也。
以有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms).
广义而言，我们所编写的每个程序都是一个算法，其中的每个函数也都是一个算法，毕竟它们都是用来解决或大或小的逻辑问题或数学问题。STL收录的算法经过了数学上的效能分析与证明，是极具复用价值的，包括常用的排序，查找等等。特定的算法往往搭配特定的数据结构，算法与数据结构相辅相成。
算法分为:质变算法和非质变算法。
质变算法：是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法：是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等
迭代器
迭代器(iterator)是一种抽象的设计概念，现实程序语言中并没有直接对应于这个概念的实物。在<>一书中提供了23中设计模式的完整描述，其中iterator模式定义如下：提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
迭代器的设计思维-STL的关键所在，STL的中心思想在于将容器(container)和算法(algorithms)分开，彼此独立设计，最后再一贴胶着剂将他们撮合在一起。从技术角度来看，容器和算法的泛型化并不困难，c++的class template和function template可分别达到目标，如果设计出两这个之间的良好的胶着剂，才是大难题。
迭代器的种类:
STL案例
#include <iostream>
//每一个容器都有自己固定的头文件，头文件名字一般就是容器名字
#include <vector>
#include <string>
#include <algorithm> //算法的头文件，大多数算法都在这个里面
#include <numeric> //算法的头文件，保存少部分
using namespace std;
//vector容器的基本简单操作
//容器中保存普通数据
void PrintFromVector(int val)
{
cout << val << " ";
}
void test1()
{
//实例化一个vector容器的对象
//注意：类模板实例化对象时，必须显式调用并制定数据类型
vector<int> v;
//调用算法插入数据
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.push_back(50);
v.push_back(60);
//如果获取容器中的数据，需要借助迭代器
//vector已经定义好了一些迭代器begin() end()
//定义一个迭代器并保存第一个数据的迭代器
vector<int>::iterator it = v.begin();
//遍历容器
#if 0
while(it != v.end())
{
cout << *it << " ";
it++;
}
cout << endl;
#endif
for_each(v.begin(), v.end(), PrintFromVector);
cout << endl;
}
//容器中保存类的对象
class Person
{
public:
Person()
{
}
Person(int id, string name, char sex)
{
this->id = id;
this->name = name;
this->sex = sex;
}
void getMsg()
{
cout << this->id << " " << this->name << " " << this->sex << endl;
}
private:
int id;
string name;
char sex;
};
void PrintFromPerson(Person p)
{
p.getMsg();
}
void test2()
{
vector<Person> v;
v.push_back(Person(1001, "zhangsan", 'B'));
v.push_back(Person(1002, "lisi", 'G'));
v.push_back(Person(1003, "wangwu", 'G'));
v.push_back(Person(1004, "zhaoliu", 'B'));
//遍历容器
//遍历方法1：使用while循环
#if 0
vector<Person>::iterator it = v.begin();
while(it != v.end())
{
//it此时相当于保存的是；类的对象的地址，所以*it就等价于类的对象
(*it).getMsg();
it++;
}
#endif
//遍历方法2：使用for循环
#if 0
for(vector<Person>::iterator it = v.begin(); it < v.end(); it++)
{
(*it).getMsg();
}
#endif
//遍历方法3：使用STL中的算法
//template<typename InputIterator, typename Function>
//Function for_each(InputIterator beg, InputIterator end, Function f) {
// while(beg != end)
// f(*beg++); --> f(*beg); beg++;
//}
for_each(v.begin(), v.end(), PrintFromPerson);
}
int main(int argc, char *argv[])
{
test2();
return 0;
}
Result:
常用容器
String容器
基本概念
C风格字符串(以空字符结尾的字符数组)太过复杂难于掌握，不适合大程序的开发，所以C++标准库定义了一种string类，定义在头文件。
String和c风格字符串对比：
Char*是一个指针，String是一个类
string封装了char，管理这个字符串，是一个char型的容器。
String封装了很多实用的成员方法
查找find，拷贝copy，删除delete 替换replace，插入insert
不用考虑内存释放和越界
string管理char*所分配的内存。每一次string的复制，取值都由string类负责维护，不用担心复制越界和取值越界等
String容器常用操作
1.构造函数
string();//创建一个空的字符串 例如: string str;
string(const string& str);//使用一个string对象初始化另一个string对象
string(const char* s);//使用字符串s初始化
string(int n, char c);//使用n个字符c初始化 v
2.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赋给当前字符串
string& assign(const string &s, int start, int n);//将s从start开始n个字符赋值给字符串
案例：
#include <iostream>
#include <string> //string容器的头文件
using namespace std;
//string的构造函数和赋值操作
void test1()
{
//构造函数
//实例化一个string的对象
string s1("hello world");
string s2 = string(s1);
cout << "s1 = " << s1 << endl;
cout << "s2 = " << s2 << endl;
string s3 = string(10, 'h');
cout << "s3 = " << s3 << endl;
//赋值操作
string s4;
s4 = "nihao beijing";
string s5;
s5 = s4;
cout << "s4 = " << s4 << endl;
cout << "s5 = " << s5 << endl;
}
int main(int argc, char *argv[])
{
test1();
return 0;
}
Result：
3.string存取字符操作
char& operator[](int n);//通过[]方式取字符
char& at(int n);//通过at方法获取字符
//string存取字符操作
void test2()
{
string s1 = "nihao beijing";
cout << s1[2] << endl;
cout << s1[7] << endl;
cout << s1.at(4) << endl;
cout << s1.at(8) << endl;
try{
//[]不会抛出异常
//cout << "s1[1000] = " << s1[1000] << endl;
//at会抛出异常
cout << "s1.at(1000) = " << s1.at(1000) << endl;
}
catch(exception &e)
{
cout << e.what() << endl;
}
}
Result：
4.string拼接操作
string& operator+=(const string& str);//重载+=操作符
string& operator+=(const char* str);//重载+=操作符
string& operator+=(const char c);//重载+=操作符
string& append(const char *s);//把字符串s连接到当前字符串结尾
string& append(const char *s, int n);//把字符串s的前n个字符连接到当前字符串结尾
string& append(const string &s);//同operator+=()
string& append(const string &s, int pos, int n);//把字符串s中从pos开始的n个字符连接到当前字符串结尾
string& append(int n, char c);//在当前字符串结尾添加n个字符c
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
6.string比较操作
/*
compare函数在>时返回 1，<时返回 -1，==时返回 0。
比较区分大小写，比较时参考字典顺序，排越前面的越小。
大写的A比小写的a小。
*/
int compare(const string &s) const;//与字符串s比较
int compare(const char *s) const;//与字符串s比较
案例
void test3()
{
//拼接操作
string s1 = string("hello world");
s1 += "nihao beildng";
cout << "s1 = " << s1 << endl;
string s2 = string("hahahaha");
s1 += s2;
cout << "s1 = " << s1 << endl;
//查找替换
int ret;
//find返回的都是实际字符串第一次出现的位置，找不到则返回-1
ret = s1.find("ld", 0);
cout << "ret = " << ret << endl;
ret = s1.find("ld", 4);
cout << "ret = " << ret << endl;
s1 += "hello world";
cout << "s1 = " << s1 << endl;
//rfind:指定位置，从当前位置之前的内容中找最后一次指定字符串出现的位置
ret = s1.rfind("ld", 20);
cout << "ret = " << ret << endl;
//replace：从指定位置开始将原本的n个数据替换成第三个参数
s1.replace(5, 100, "123456");
cout << "s1 = " << s1 << endl;
}
Result：
7.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 test4()
{
string s1 = string("hello world");
s1.insert(5, "666666");
cout << "s1 = " << s1 << endl;
s1.erase(5, 6);
cout << "s1 = " << s1 << endl;
}
Result：
8.string子串
string substr(int pos = 0, int n = npos) const;//返回由pos开始的n个字符组成的字符串
案例：
//子串
void test5()
{
string s1 = string("123456789");
cout << "s1 = " << s1 << endl;
string s2 = s1.substr(0, 4);
cout << "s2 = " << s2 << endl;
s2 = s1.substr(4, 4);
cout << "s2 = " << s2 << endl;
}
void test6()
{
//使用vector保存切割后的数据
string s1 = string("11111:222222222:3333333:444444:55555555");
// int pos = s1.find(':', 0);
// cout << "pos = " << pos << endl;
// string s2 = s1.substr(0, pos);
// cout << "s2 = " << s2 << endl;
// int ret = pos;
// pos = s1.find(':', pos + 1);
// s2 = s1.substr(ret + 1, pos - ret - 1);
// cout << "s2 = " << s2 << endl;
//定义vector对象
vector<string> v;
int pos = 0, ret;
pos = s1.find(':', pos);
v.push_back(s1.substr(0, pos));
ret = pos;
while((pos = s1.find(':', pos + 1)) != -1)
{
v.push_back(s1.substr(ret + 1, pos - ret - 1));
ret = pos;
}
//处理最后一部分内容
//cout << "s1.size = " << s1.size() << endl;
v.push_back(s1.substr(ret + 1, s1.size() - ret - 1));
for(vector<string>::iterator it = v.begin(); it < v.end(); it++)
{
//it --> string *
//*it --> string
cout << *it << endl;
}
}
Result：
9.string和c-style字符串转换
//string 转 char*
string str = "itcast";
const char* cstr = str.c_str();
//char* 转 string
char* s = "itcast";
string str(s);
string空间的使用问题
void test7()
{
string s = string("abcdefghijk");
cout << "容量：" << s.capacity() << endl;
char &s1 = s[5];
char &s2 = s[7];
cout << "s = " << s << endl;
s1 = '8';
s2 = '5';
cout << "s = " << s << endl;
s = "kkkkkkkkkk";
cout << "s = " << s << endl;
cout << "s1 = " << s1 << ", s2 = " << s2 << endl;
cout << "容量：" << s.capacity() << endl;
cout << (int*)s.c_str() << endl;
s = "hhhhhhhhhhhhhhhhhhhhhhhhhh";
cout << "s = " << s << endl;
cout << "s1 = " << s1 << ", s2 = " << s2 << endl;
cout << "容量：" << s.capacity() << endl;
cout << (int*)s.c_str() << endl;
}
Result:
vector容器
概念
vector的数据安排以及操作方式，与array非常相似，两者的唯一差别在于空间的运用的灵活性。Array
是静态空间，一旦配置了就不能改变，要换大一点或者小一点的空间，可以，一切琐碎得由自己来，首先配置一块新的空间，然后将旧空间的数据搬往新空间，再释放原来的空间。Vector是动态空间，随着元素的加入，它的内部机制会自动扩充空间以容纳新元素。因此vector的运用对于内存的合理利用与运用的灵活性有很大的帮助，我们再也不必害怕空间不足而一开始就要求一个大块头的array了。
vector迭代器是一个随机访问迭代器，所以可以执行任意操作
Vector维护一个线性空间，所以不论元素的型别如何，普通指针都可以作为vector的迭代器，因为
vector迭代器所需要的操作行为，如operaroe, operator->, operator++, operator–, operator+,
operator-, operator+=, operator-=, 普通指针天生具备。
vector的未雨绸缪机制
#include <iostream>
#include <vector>
#include <stdio.h>
using namespace std;
//vector的未雨绸缪机制
//vector会随着数据插入的个数增多而扩大开辟的空间
//但是他会事先多开辟一些空间，减少每次开辟空间的个数和时间，提高效率
//只要容量不够，会先释放原来的空间，然后开辟新空间
void test1()
{
vector<int> v;
cout << "容量：" << v.capacity() << endl;
cout << "实际使用：" << v.size() << endl;
for(int i = 1; i <= 10; i++)
{
v.push_back(i + 10);
cout << "i = " << i << endl;
cout << "容量：" << v.capacity() << endl;
cout << "实际使用：" << v.size() << endl;
printf("&v[0] = %p\n", &v[0]);
}
}
int main(int argc, char *argv[])
{
test1();
return 0;
}
Result：
vector常用API操作
1.构造函数
vector<T> v; //采用模板实现类实现，默认构造函数
vector(v.begin(), v.end());//将v[begin(), end())区间中的元素拷贝给本身。
vector(n, elem);//构造函数将n个elem拷贝给本身。
vector(const vector &vec);//拷贝构造函数。
//例子 使用第二个构造函数 我们可以...
int arr[] = {2,3,4,1,9};
vector<int> v1(arr, arr + sizeof(arr) / sizeof(int));
2.常用赋值操作
assign(beg, end);//将[beg, end)区间中的数据拷贝赋值给本身。
assign(n, elem);//将n个elem拷贝赋值给本身。
vector& operator=(const vector &vec);//重载等号操作符
swap(vec);// 将vec与本身的元素互换。
案例
//构造函数和赋值操作
void test2()
{
int a[] = {6, 5, 8, 9, 4};
vector<int> v = vector<int>(a, a + sizeof(a) / sizeof(a[0]));
PrintVectorInt(v);
vector<int> v1;
v1 = v;
PrintVectorInt(v1);
for(int i = 1; i <= 20; i++)
{
v1.push_back(i);
}
PrintVectorInt(v1);
cout << "v容量：" << v.capacity() << "， 实际使用："<< v.size() << endl;
cout << "v1容量：" << v1.capacity() << "， 实际使用："<< v1.size() << endl;
//swap函数是将两个容器的容量和实际使用个数都直接交换
v.swap(v1);
cout << "v容量：" << v.capacity() << "， 实际使用："<< v.size() << endl;
cout << "v1容量：" << v1.capacity() << "， 实际使用："<< v1.size() << endl;
}
Result：
3.大小操作
size();//返回容器中元素的个数
empty();//判断容器是否为空
resize(int num);
//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。
//如果容器变短，则末尾超出容器长度的元素被删除。
resize(int num, elem);
//重新指定容器的长度为num，若容器变长，则以elem值填充新位置。
//如果容器变短，则末尾超出容器长>度的元素被删除。
capacity();//容器的容量
reserve(int len);//容器预留len个元素长度，预留位置不初始化，元素不可访问。
4.数据存取操作
at(int idx); //返回索引idx所指的数据，如果idx越界，抛出out_of_range异常。
operator[];//返回索引idx所指的数据，越界时，运行直接报错
front();//返回容器中第一个数据元素
back();//返回容器中最后一个数据元素
5.插入和删除操作
insert(const_iterator pos, int count,ele);//迭代器指向位置pos插入count个元素ele.
push_back(ele); //尾部插入元素ele
pop_back();//删除最后一个元素
erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素
erase(const_iterator pos);//删除迭代器指向的元素
clear();//删除容器中所有元素
vector容量问题
//vector容量问题
void test5()
{
vector<int> v;
int *p = NULL;
int num = 0;
//如果事先知道插入容器的数据的个数，可以提前预留空间，减少重新开辟空间的次数
v.reserve(100);
for(int i = 1; i <= 100; i++)
{
v.push_back(i);
if(p != &v[0]) //只要重新开辟空间，v[0]地址就会改变
{
num++;
p = &v[0];
}
}
cout << "开辟空间的次数为：" << num << endl;
}
void test6()
{
vector<int> v;
v.reserve(1000);
v.push_back(10);
v.push_back(20);
v.push_back(30);
v.push_back(40);
v.push_back(50);
cout << "容量：" << v.capacity() << "， 实际使用：" << v.size() << endl;
//v.resize(5);
//v.reserve(5);
{
vector<int> v1;
v1 = v;
v.swap(v1);
}
//vector<int>(v) --> vector<int> v1; v1 = v; v1.swap(v);
//如果预留的空间过多，则会导致空间浪费，所以需要改变原本容器的容量
//可以使用匿名对象调用有参构造函数并交换
vector<int>(v).swap(v);
cout << "v容量：" << v.capacity() << "， 实际使用：" << v.size() << endl;
}
本次记录先到这里~下一章继续学习奇怪的知识啦！！
675
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
