【C++】STL--string和vector容器

string容器

本质：

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

string和char*区别：

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

特点：
string类中封装了很多成员方法
string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

string构造函数

string(); //创建一个空的字符串 例如: string str;
string(const char* s);//使用字符串s初始化
string(const string& str); //使用一个string对象初始化另一个string对象
string(int n,char c); //使用n个字符c初始化

string 赋值操作

1.string s1 = s2;//拷贝构造赋值
2.s1.assign("hello world!");//用assign（赋值）的方式赋值
3.s1.assign("hello world!",5)//s1为hello
4.s1.assign(s2);//拷贝构造赋值
5.s1.assign(7,"w");/s1为7个w

string 字符串拼接

string str1="我";
string str2="LOL"
1.str1+="爱玩游戏"; //我爱玩游戏
2.str1+=':';//我：
3.str1 += str2;//我LOL
4.str1.append("love");//我love
5.str1.append("hello world",5);//我hello
6.str1.append(str2);//我LOL
7.str1.append(str2,0,2);//我LO (从0位置开始截取，截取两个字符)

string 查找和替换

string str1="abcdefgde";
1.int pos = str1.find("de")//返回3,从左往右查找，如果未找到返回-1
2.int pos = str1.rfind("de")//返回7，从右往左查找
3.str1.replace(1,3,"1111");//str1为a1111efgde，从一号位置起，三个字符替换为1111

string 字符串比较

字符串比较是按字符的ASCII码进行对比
= 返回0
> 返回1
< 返回-1

string s1="hello";
string s2="hello";
int ans = s1.compare(str2);//返回0

string 字符存取

string str = "hello";
str[0];//h 访问
str.at(0);//h 访问
str[0]='x';//str变成xello  修改
str.at(0)='x';//同理

string 插入和删除

string 子串获取

vector容器

头文件： #include <vector>

数组是静态空间，vector是动态数组,可以动态扩展。
动态扩展：寻找更大的内存空间，将原数据拷贝到新空间，释放原空间

#include <vector>
int main()
{
    vector<int> a;//相当于一个长度动态变化的int数组
    vector<int> b[233];//相当于第一维长233，第二位长度动态变化的int数组
    typedef struct rec {
        int c;
        int d;
    }person;
    vector<person> e;		//自定义的结构体类型也可以保存在vector中
    return 0;
}

插入数据–pushback和迭代器遍历

迭代器：类似于指针.

vector<int>::iterator itBegin = v.begin();
在vector容器中有一个迭代器类型（我们可以理解为指针类型），定义 itBegin 存放初始地址.

#include <vector>
int main()
{
    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++;
    }
    return 0;
}

第二种遍历
for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
{
    cout << *it << endl;
}

第三种遍历
#include <algorithm>//标准算法头文件
//声明一个函数
void myPrint(int val)
{
    cout << val << endl;
}
for_each(v.begin(), v.end(), myPrint);//算法库里的遍历函数
//循环条件：首索引 != 尾索引，会自动加加，用结果调用函数

vector存放自定义类型数据

#include <string>
#include <vector>
class Person
{
public:
    Person(string name,int age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }
    string m_Name;
    int m_Age;
};

int main()
{
    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 << endl;
        cout << (*it).m_Age << endl;
    }
}

容器中嵌套容器

#include <vector>

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++)
    {
        for (vector<int>::iterator it1 = (*it).begin(); it1 != (*it).end(); it1++)
        {
            cout << (*it1) << " ";
        }
        cout << endl;
    }

}


int main()
{
    test01();
}

运行结果：

1 2 3 4
2 3 4 5
3 4 5 6
4 5 6 7

vector 构造函数

功能：创造vector容器

vector<int>v1; 
// 默认构造
vector<int>v2(v1.begin(), v1.end());
//通过区间方式构造 ，v2 = v1
vector<int>v3(10, 100);
//10是个数，100是值，类似于一个数组存储了10个100

vector 赋值操作

1.vector v2 = v1—等号赋值
2.assign(beg,end) —将[beg,end)区间中的数据拷贝赋值给本身
3.assign(n,elem)—将n个elem拷贝赋值给本身—element(元素),assign(赋值,分配)

#include <vector>
void printVector(vector<int> &v)
{
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}

int main()
{
	vector<int>v1;
	for (int i = 0; i < 10;i++)
	{
		v1.push_back(i);
	}
	printVector(v1);

	//=
	vector<int> v2;
	v2 = v1;//v1的所有都被赋值给v2了
	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);
	return 0;
}

vector 容量和大小

• empty();                     判断容器是否为空
  capacity();                  返回容器的容量
  size()                          返回元素的个数（容器储存的大小）
  resize(int num);          重新指定容器的长度(大小)，如果变长，则新位置填充默认值0，如变短则超出容器长度的元素被删除,但是容量不变
  resize(int num,elem);  重新指定容器的长度，如果变长，则新位置以elem填充，如变短则超出容器长度的元素被删除，容量不变

vector 插入和删除

对 vector 进行插入，删除操作

• push_back(elem) //尾部插入元素ele
• pop_back(); //删除最后一个元素
• insert(const_iterator pos,ele); //迭代器指向位置pos插入元素ele
• erase(const_iterator pos); //删除元素
• erase(const_iterator start, const_iterator end); //删除迭代器从start到end之间的元素
• clear(); //删除容器中所有元素

vector 数据存取

对vector中的数据的存取操作

• at(int idx); //返回索引idx所指的数据
• 利用[ ]方式访问数组中元素
• front(); //返回容器中第一个数据元素
• back(); //返回容器中最后一个数据元素

vector<int> v1;
//获取i位置上的数据
v1.at(i);
v1[i];

vector 互换容器

将容器内的元素互换。（实质是v1指向了v2指向的数据，v2指向了v1的数据）

vector v1;
vector v2;
v1.swap(v2);//v1变成v2，v2变成v1

vector 预留空间

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

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