初识STL
- **STL的基本概念**
- **vector容器存放内置数据类型**
- **在vector容器中存放自定义数据类型**
- **vector容器嵌套vector容器**
- **string容器——构造函数**
- **string容器——赋值操作**
- **string容器——字符串拼接**
- **string容器——字符串的查找和替换**
- **string容器——字符串比较**
- **string容器——字符存取**
- **string容器——字符串的插入和删除**
- **string容器——字串获取**
- **vector容器——构造函数**
- **vector容器——赋值操作**
- **vector容器——容量和大小**
- **vector容器——插入和删除**
- **vector容器——数据存取**
- **vector容器——互换容器**
- **vector容器——预留空间**
STL的基本概念
STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器(配接器)、空间配置器
1.容器:各种数据结构，如vector、list、deque、set、map等,用来存放数据。
2.算法:各种常用的算法，如sort、find、copy、for_each等
3.迭代器:扮演了容器与算法之间的胶合剂。
4.仿函数:行为类似函数，可作为算法的某种策略。
5.适配器:一种用来修饰容器或者仿函数或迭代器接口的东西。
6.空间配置器:负责空间的配置与管理。
容器:置物之所也
STL容器就是将运用最广泛的一些数据结构实现出来常用的数据结构:数组,链表,树,栈,队列,集合,映射表等
这些容器分为序列式容器和关联式溶容器两种:
序列式容器:强调值的排序，序列式容器中的每个元素均有固定的位置。
关联式容器:二叉树结构，各元素之间没有严格的物理上的顺序关系
算法:问题之解法也
有限的步骤，解决逻辑或数学上的问题，这一门学科我们叫做算法(Algorithms)算法分为:
质变算法和非质变算法。
质变算法:是指运算过程中会更改区间内的元素的内容。例如拷贝，替换，删除等等
非质变算法∶是指运算过程中不会更改区间内的元素内容，例如查找、计数、遍历、寻找极值等等
迭代器:容器和算法之间粘合剂
提供一种方法，使之能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。
每个容器都有自己专属的迭代器，迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针
算法必须要通过迭代器来访问容器中的元素
常用的容器中迭代器种类为双向迭代器和随机访问迭代器
vector容器存放内置数据类型
STL中最常用的容器为Vector，可以理解为数组，利用这个容器中可以实现插入数据、并遍历这个容器
iterator是迭代器的名称，是在vector类型下的
//#define _CRT_SECURE_NO_WARNINGS
//#include <iostream>
//using namespace std;
//int main()
//{
// system("pause");
// return EXIT_SUCCESS;
//}
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <vector>
#include <algorithm>//标准算法的头文件
//vector容器存放内置数据类型
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);
通过迭代器访问容器中的数据
//vector<int>::iterator itBegin = v.begin();//起始迭代器 指向容器中第一个元素
//vector<int>::iterator itEnd = v.end();//结束迭代器 指向的是最后一个元素的下一个位置
//
第一种遍历方式
//while (itBegin != itEnd)
//{
// cout << *itBegin << endl;
// itBegin++;
//}
第二种遍历方式
//for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
//{
// cout << *it << endl;
//}
//第三种遍历方式 利用STL提供的遍历算法
for_each(v.begin(), v.end(), myPrint);//这里写一个函数名 利用了回调的技术
//在遍历的期间 调用了函数
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
第三种函数的源码:
这里是用了回调函数还有一个for循环来实现的
这里的迭代器可以看成指针，而解引用就是解这个指针，然后把解引用的元素放入到回调函数进行调用
在vector容器中存放自定义数据类型
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <vector>
#include <string>
//vector存放自定义的数据类型
class Person
{
public:
Person(string name, int age)
{
this->m_Name = name;
this->m_Age = age;
}
string m_Name;
int m_Age;
};
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 << "姓名:" << (*it).m_Name << " 年龄:" << (*it).m_Age << endl;
//cout << "姓名:" << it->m_Name << " 年龄:" << it->m_Age << 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);
//遍历容器
//此时的it可以理解为二级指针
for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
{
cout << "姓名:" << (*it)->m_Name << " 年龄:" << (*it)->m_Age << endl;
}
}
int main()
{
//test01();
test02();
system("pause");
return EXIT_SUCCESS;
}
vector容器嵌套vector容器
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
//容器嵌套容器
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);
}
//将小容器插入到大容器中
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++)
{
//(*it)------容器 vector<int>
for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
{
cout << *vit << " ";
}
cout << endl;
}
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
string容器——构造函数
string本质:
string是C++风格的字符串，而string本质上是一个类string和char区别:
char是一个指针
string是一个类，类内部封装了char，管理这个字符串，是一个char型的容器。
特点:
string类内部封装了很多成员方法
例如︰查找find，拷贝copy，删除delete替换replace，插入insertstring管理char所分配的内存，不用担心复制越界和取值越界等由类内部进行负责*
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
#include <string>
//string的构造函数
void test01()
{
string s1;//默认构造
const char * str = "hello world";
string s2(str);
cout << "s2=" << s2 << endl;
string s3(s2);
cout << "s3=" << s3 << endl;
string s4(10, 'a');
cout << "s4=" << s4 << endl;
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
string容器——赋值操作
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
void test01()
{
string str1;
str1 = "hello world";
cout << "str1=" << str1 << endl;
string str2;
str2 = str1;
cout << "str2=" << str1 << 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(10, 'w');
cout << "str7=" << str7 << endl;
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
string容器——字符串拼接
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
//string字符凭借
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 ");//append中文是增加
cout << "str3=" << str3 << endl;
str3.append("game abcde", 4);
cout << "str3=" << str3 << endl;
/*str3.append(str2);
cout << "str3=" << str3 << endl;*/
/*str3.append(str2,0,4);
cout << "str3=" << str3 << endl;*/
str3.append(str2, 4, 4);
cout << "str3=" << str3 << endl;
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
string容器——字符串的查找和替换
第一个函数原型：查找的是数组的下标，查找不到就输出-1
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
//string 字符串的查找和替换
//1、查找 find
void test01()
{
string str1 = "abcdefgde";
int pos = str1.find("de");
cout << "pos=" << pos << endl;
int abc = str1.find("df");
cout << "abc=" << abc << endl;
//1、查找 rfind
pos = str1.rfind("de");
cout << "pos=" << pos << endl;
//rfind和find区别
//rfind从右往左查 find从左往右查
}
//2、替换
void test02()
{
string str1 = "abcdefg";
//从1号位置起3个字符替换为"1111"
str1.replace(1, 3, "1111"); //把bcd换成1111
cout << "str1=" << str1 << endl;
}
int main()
{
test01();
test02();
system("pause");
return EXIT_SUCCESS;
}
string容器——字符串比较
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
//string 字符串比较
void test01()
{
string str1 = "hello";
string str2 = "hello";
if (str1.compare(str2) == 0)
{
cout << "str1 等于 str2" << endl;
}
else if (str1.compare(str2) > 0)
{
cout << "str1 大于 str2" << endl;
}
else if (str1.compare(str2) < 0)
{
cout << "str1 小于 str2" << endl;
}
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
总结:字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大
string容器——字符存取
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
//string 字符存取
//底层是字符数组
void test01()
{
string str = "hello";
//cout << "str=" << str << endl;
//1、通过[]访问单个字符
for (unsigned int i = 0; i < str.size(); i++)
{
cout << str[i] <<" ";
}
cout << endl;
//2、通过at方式访问你单个字符
for (unsigned int i = 0; i < str.size(); i++)
{
cout << str.at(i) << " ";
}
cout << endl;
//修改单个字符
str[0] = 's';
cout << "str=" << str << endl;
str.at(1) = 'b';
cout << "str=" << str << endl;
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
string容器——字符串的插入和删除
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
//string 字符串的插入和删除
void test01()
{
string str = "hello";
//插入
str.insert(1, "111");
cout << "str=" << str << endl;
//删除
str.erase(1, 3);
cout << "str=" << str << endl;
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
string容器——字串获取
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
using namespace std;
//string 字串获取
void test01()
{
string str = "abcdef";
//数组下标为1往后数三个
string subStr = str.substr(1, 3);
cout << "subStr=" << subStr << endl;
}
//实用操作
void test02()
{
string email = "zhangsan@sina.com";
//从邮件的地址中 获取 用户名的信息
int pos = email.find("@");
cout << pos << endl;
string userName = email.substr(0, pos);//从email数组下标为0的元素开始截取8哥字符
cout << userName << endl;
}
int main()
{
//test01();
test02();
system("pause");
return EXIT_SUCCESS;
}
这里find找到@的位置为8是数组下标，我们要截取的zhangsan这个字符串长度也是8，直接把pos传进去就行了
总结:灵活的运用求子串功能，可以在实际开发中获取有效的信息
vector容器——构造函数
功能:
vector数据结构和数组非常相似，也称为单端数组
vector与普通数组区别:
不同之处在于数组是静态空间，而vector可以动态扩展
动态拓展:
并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间
vector的迭代器是支持随机访问的迭代器
这里的begin()是闭区间，end()是开区间
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
void printVector(vector<int>&v)
{
//vector容器可以看成数组
//迭代器可以看成指针
//在C++中，vector是一个动态数组，可以根据需要自动扩展或缩小。
//v.begin()是vector容器的一个成员函数，它返回一个指向容器中第一个元素的迭代器。
//所以创建了一个名为v的vector容器，v.begin()将返回一个指向v中第一个元素的迭代器
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//vector容器
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);
//n个elem方式构造
//第一个参数是个数 第二个是赋值
vector<int>v3(10, 100);
printVector(v3);
//拷贝构造
vector<int>v4(v3);
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
这里打印函数为什么要加入引用的原因是：
不加引用程序就需要重新构建一个vector，这会浪费很多的计算机资源，加引用就是为了避免这个的
vector容器——赋值操作
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
void printVector(vector<int>&v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//vector赋值
void test01()
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
printVector(v1);
//赋值 operator=
vector<int>v2;
v2 = v1;
printVector(v2);
//assign
vector<int>v3;
//前闭后开
v3.assign(v1.begin(), v1.end());
printVector(v3);
//n个elem方式赋值
vector<int>v4;
v4.assign(10, 100);
printVector(v4);
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
vector容器——容量和大小
判断是否为空— empty
返回元素个数— size
返回容器容量— capacity
重新指定大小 — resize
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
void printVector(vector<int>&v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//vector容器的容量和大小操作
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;
}
//重新指定大小
v1.resize(15,100);//利用重载版本，可以指定默认的填充值
printVector(v1);//如果重新指定的比原来长了 默认用0填充
v1.resize(5);
printVector(v1);//如果重新指定的比原来短了 超出部分会删除掉
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
vector容器——插入和删除
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
void printVector(vector<int>&v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//vector插入和删除
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 EXIT_SUCCESS;
}
vector容器——数据存取
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
//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;
//利用at方式访问元素
for (int i = 0; i < v1.size(); i++)
{
cout << v1.at(i) << " ";
}
cout << endl;
//获取第一个元素
cout << "第一个元素为:" << v1.front() << endl;
//获取最后一个元素
cout << "第一个元素为:" << v1.back() << endl;
}
int main()
{
test01();
system("pause");
return EXIT_SUCCESS;
}
总结:
除了用迭代器获取vector容器中元素，[]和l也可以
front返回容器第一个元素
back返回容器最后一个元素
vector容器——互换容器
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
//vector容器互换
void printVector(vector<int>&v)
{
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
cout << *it << " ";
}
cout << endl;
}
//1、基本使用
void test01()
{
vector<int>v1;
for (int i = 0; i < 10; i++)
{
v1.push_back(i);
}
cout << "交换前:" << endl;
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);
}
//2、实际用途
//可以巧用swap可以收缩内存空间
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;
//巧用swap收缩内存
//vector<int>(v)//匿名对象 调用了一次拷贝构造函数
//用v所用的内存空间来初始化x的内存空间
//.swap(v)相当于容器之间的交换
//匿名对象的特点 执行完就会回收空间
vector<int>(v).swap(v);
cout << "v的容量: " << v.capacity() << endl;
cout << "v的大小: " << v.size() << endl;
}
int main()
{
//test01();
test02();
system("pause");
return EXIT_SUCCESS;
}
vector容器——预留空间
功能：
减少vector在动态扩展容量时的扩展次数
没有设置预留空间：
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
//vector容器 预留空间
void test01()
{
int num = 0;//统计开辟次数
int *p = NULL;
vector<int>v;
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 EXIT_SUCCESS;
}
设置了预留空间：
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;
//vector容器 预留空间
void test01()
{
int num = 0;//统计开辟次数
int *p = NULL;
vector<int>v;
//利用reserve来预留空间
v.reserve(100000);
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 EXIT_SUCCESS;
}
