C++ STL常用标准模板库

已于 2023-10-11 18:39:47 修改
阅读量66 收藏
点赞数
文章标签： stl c++
于 2023-10-10 18:31:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_75034791/article/details/133750784
版权

一. STL基本概念

STL(Standard Template Library)，从广义上分为: 容器、算法、迭代器。其中，容器和算法之间通过迭代器进行无缝连接。而STL中几乎所有的代码都采用了模板类或者模板函数。

1. STL六大组件

STL大体分为六大组件，分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器

  1. 容器：各种数据结构，如vector、list、deque、set、map等，用来存放数据。

  2. 算法：各种常用的算法，如sort、find、copy、for_each等。

  3. 迭代器：将容器与算法进行连接。

  4. 仿函数：行为类似函数，可作为算法的某种策略。

  5. 适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。

  6. 空间配置器：负责空间的配置与管理。

2. STL中容器、算法、迭代器

1. 容器

常用的数据结构：数组, 链表,树, 栈, 队列, 集合, 映射表 等

这些容器分为两种:

序列式容器：强调值的排序，序列式容器中的每个元素均有固定的位置。

关联式容器：二叉树结构，各元素之间没有严格的物理上的顺序关系

2. 算法

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

质变算法：运算过程中更改区间内的元素的内容。例如拷贝，替换，删除等等

非质变算法：运算过程中不更改区间内的元素内容，例如查找、计数、遍历、找极值等等

3. 迭代器

提供一种方法，能够依序寻访某个容器所含的各个元素，而又无需暴露该容器的内部表示方式。每个容器都有自己专属的迭代器。

迭代器使用非常类似于指针，初学阶段我们可以先理解迭代器为指针

迭代器种类：

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

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

 

二. vector容器

1. vector基本概念

vector和数组非常相似，也称为单端数组，不同在于数组是静态空间，而vector可以动态扩展。

动态扩展：并不是在原空间之后续接新空间，而是找更大的内存空间，然后将原数据拷贝新空间，释放原空间。

2. vector构造函数

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

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

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

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

#include <vector>
​
void printVector(vector<int>& v) {
​
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
​
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);
​
    vector<int> v3(10, 100);
    printVector(v3);
    
    vector<int> v4(v3);
    printVector(v4);
}
​
int main() {
    test01();
    system("pause");
    return 0;
}

3. vector赋值操作

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

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

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

#include <vector>
​
void printVector(vector<int>& v) {
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
​
//赋值操作
void test01(){
    vector<int> v1; //无参构造
    for (int i = 0; i < 10; i++){
        v1.push_back(i);
    }
    printVector(v1);
​
    vector<int>v2;
    v2 = v1;
    printVector(v2);
​
    vector<int>v3;
    v3.assign(v1.begin(), v1.end());
    printVector(v3);
​
    vector<int>v4;
    v4.assign(10, 100);
    printVector(v4);
}
​
int main() {
    test01();
    system("pause");
    return 0;
}
​

vector赋值方式比较简单，使用=，或者assign都可以

 

4. vector容量和大小

  • empty(); //判空

  • capacity(); //容量

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

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

  • resize(int num, elem); //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出的元素被删除

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

    //resize 重新指定大小 ，若指定的更大，默认用0填充新位置，可以利用重载版本替换默认填充
    v1.resize(15,10);
    printVector(v1);
    //resize 重新指定大小 ，若指定的更小，超出部分元素被删除
    v1.resize(5);
    printVector(v1);
}
​
int main() {
    test01();
    system("pause");
    return 0;
}

5. vector插入和删除

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

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

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

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

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

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

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

#include <vector>
​
void printVector(vector<int>& v) {
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
​
//插入和删除
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 0;
}

6. vector数据存取

  • at(int idx); //返回idx所指的数据

  • operator[]; //返回idx所指的数据

  • front(); //返回容器中第一个数据元素

  • back(); //返回容器中最后一个数据元素

#include <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;
​
    for (int i = 0; i < v1.size(); i++){
        cout << v1.at(i) << " ";
    }
    cout << endl;
​
    cout << "v1的第一个元素为： " << v1.front() << endl;
    cout << "v1的最后一个元素为： " << v1.back() << endl;
}
​
int main() {
    test01();
    system("pause");
    return 0;
}

7. vector互换容器

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

#include <vector>
​
void printVector(vector<int>& v) {
    for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
        cout << *it << " ";
    }
    cout << endl;
}
​
void test01(){
    vector<int>v1;
    for (int i = 0; i < 10; i++){
        v1.push_back(i);
    }
    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);
}
​
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;
​
    //收缩内存
    vector<int>(v).swap(v); //匿名对象
    cout << "v的容量为：" << v.capacity() << endl;
    cout << "v的大小为：" << v.size() << endl;
}
​
int main() {
    test01();
    test02();
    system("pause");
    return 0;
}
​

swap可以使两个容器互换，可以达到实用的收缩内存效果

8. vector预留空间

作用描述：减少vector在动态扩展容量时的扩展次数

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

#include <vector>
​
void test01(){
    vector<int> v;
    //预留空间
    v.reserve(100000);
​
    int num = 0;
    int* p = NULL;
    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 0;
}

总结：如果数据量较大，可以一开始利用reserve预留空间

 9. vector存放内置数据类型

#include <vector>
#include <algorithm>

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);

	//每一个容器都有自己的迭代器，迭代器是用来遍历容器中的元素
	//v.begin()返回迭代器，这个迭代器指向容器中第一个数据
	//v.end()返回迭代器，这个迭代器指向容器元素的最后一个元素的下一个位置
	//vector<int>::iterator 拿到vector<int>这种容器的迭代器类型

	vector<int>::iterator pBegin = v.begin();
	vector<int>::iterator pEnd = v.end();

	//第一种遍历方式：
	while (pBegin != pEnd) {
		cout << *pBegin << endl;
		pBegin++;
	}
	//第二种遍历方式：
	for (vector<int>::iterator it = v.begin(); it != v.end(); it++) {
		cout << *it << endl;
	}
	cout << endl;
	//第三种遍历方式：使用STL提供标准遍历算法，头文件<algorithm>
	for_each(v.begin(), v.end(), MyPrint);
}

int main() {
	test01();
	system("pause");
	return 0;
}

10. vector存放自定义数据类型

#include <vector>
#include <string>

//自定义数据类型
class Person {
public:
	Person(string name, int age) {
		mName = name;
		mAge = age;
	}
public:
	string mName;
	int mAge;
};
//存放对象
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 << "Name:" << (*it).mName << " Age:" << (*it).mAge << 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);

	for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++) {
		Person * p = (*it);
		cout << "Name:" << p->mName << " Age:" << (*it)->mAge << endl;
	}
}

int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

11. vector容器的嵌套

#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);
	}
	//将容器元素插入到vector v中
	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 vit = (*it).begin(); vit != (*it).end(); vit++) {
			cout << *vit << " ";
		}
		cout << endl;
	}
}

int main() {
	test01();
	system("pause");
	return 0;
}

 

三. string容器

1. string基本概念

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

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

特点：string 类内部封装了很多成员方法

例如：查找find，拷贝copy，删除delete，替换replace，插入insert

string管理char*所分配的内存，不用担心复制越界和取值越界等，由类内部进行负责

2. string构造函数

  • string(); //创建一个空的字符串 例如: string str; string(const char* s); //使用字符串s初始化

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

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

 #include <string>
    //string构造
    void test01() {
        string s1; //创建空字符串，调用无参构造函数
        cout << "str1 = " << s1 << endl;
    
        const char* str = "hello world";
        string s2(str); //把c_string转换成了string
    
        cout << "str2 = " << s2 << endl;
    
        string s3(s2); //调用拷贝构造函数
        cout << "str3 = " << s3 << endl;
    
        string s4(10, 'a');
        cout << "str3 = " << s3 << endl;
    }
    
    int main() {
        test01();
        system("pause");
        return 0;
    }

3. 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赋给当前字符串

 //赋值
    void test01(){
        string str1;
        str1 = "hello world";
        cout << "str1 = " << str1 << endl;
    
        string str2;
        str2 = str1;
        cout << "str2 = " << str2 << 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(5, 'x');
        cout << "str7 = " << str7 << endl;
    }
    
    int main() {
        test01();
        system("pause");
        return 0;
    }

    string的赋值方式很多，operator=  这种方式是比较实用的

4. string字符串拼接

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

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

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

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

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

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

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

//字符串拼接
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 ");
    str3.append("game abcde", 4);
    //str3.append(str2);
    str3.append(str2, 4, 3); // 从下标4位置开始 ，截取3个字符，拼接到字符串末尾
    cout << "str3 = " << str3 << endl;
    }
    
int main() {
    test01();
    system("pause");
    return 0;
    }

总结：字符串拼接的重载版本很多，初学阶段记住几种即可

5. string查找和替换

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

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

  • 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个字符为字符串

  //查找和替换
    void test01(){
        //查找
        string str1 = "abcdefgde";
        int pos = str1.find("de");
        if (pos == -1) {
            cout << "未找到" << endl;
        }
        else {
            cout << "pos = " << pos << endl;
        }
        pos = str1.rfind("de");
        cout << "pos = " << pos << endl;
    }
    
    void test02(){
        //替换
        string str1 = "abcdefgde";
        str1.replace(1, 3, "1111");
        cout << "str1 = " << str1 << endl;
    }
    
    int main() {
        //test01();
        //test02();
        system("pause");
        return 0;
    }

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

6. string字符串比较

比较方式：字符串比较是按字符的ASCII码进行对比

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

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

字符串对比主要是用于比较两个字符串是否相等，判断谁大谁小的意义并不是很大

7. string字符存取

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

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

8. 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个字符 

插入和删除的起始下标都是从0开始

9. string子串

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

 

四. deque容器

1. deque容器基本概念

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

deque与vector区别：

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

deque内部工作原理：deque内部有个中控器，维护每段缓冲区中的内容，缓冲区中存放真实数据，中控器维护的是每个缓冲区的地址，使得使用deque时像一片连续的内存空间

deque容器的迭代器也是支持随机访问的

2. deque构造函数

  • deque<T> deqT;                    //默认构造形式
  • deque(beg, end);                   //构造函数将[beg, end)区间中的元素拷贝给本身。
  • deque(n, elem);                     //构造函数将n个elem拷贝给本身。
  • deque(const deque &deq);   //拷贝构造函数

deque容器和vector容器的构造方式几乎一致，灵活使用即可

3. deque赋值操作

  • deque& operator=(const deque &deq);         //重载等号操作符
  • assign(beg, end);                                          //将[beg, end)区间中的数据拷贝赋值给本身。
  • assign(n, elem);                                            //将n个elem拷贝赋值给本身。

deque赋值操作也与vector相同，需熟练掌握

4. deque大小操作

  • deque.empty();                       //判断容器是否为空
  • deque.size();                         //返回容器中元素的个数
  • deque.resize(num);                //重新指定容器的长度为num,若容器变长，则以默认值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。
  • deque.resize(num, elem);     //重新指定容器的长度为num,若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

deque没有容量的概念
 

5. deque 插入和删除

两端插入操作：

  • push_back(elem);          //在容器尾部添加一个数据
  • push_front(elem);        //在容器头部插入一个数据
  • pop_back();                   //删除容器最后一个数据
  • pop_front();                 //删除容器第一个数据

指定位置操作：

  • insert(pos,elem);         //在pos位置插入一个elem元素的拷贝，返回新数据的位置。
  • insert(pos,n,elem);     //在pos位置插入n个elem数据，无返回值。
  • insert(pos,beg,end);    //在pos位置插入[beg,end)区间的数据，无返回值。
  • clear();                           //清空容器的所有数据
  • erase(beg,end);             //删除[beg,end)区间的数据，返回下一个数据的位置。
  • erase(pos);                    //删除pos位置的数据，返回下一个数据的位置。

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

6. deque 数据存取

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

7. deque 排序

  • sort(iterator beg, iterator end)  //对beg和end区间内元素进行排序

 

五. stack容器

1. stack 基本概念

概念：stack是一种先进后出(First In Last Out,FILO)的数据结构，它只有一个出口

栈中只有顶端的元素才可以被外界使用。

2. stack 常用接口

构造函数：

  • stack<T> stk;                                 //stack采用模板类实现， stack对象的默认构造形式
  • stack(const stack &stk);            //拷贝构造函数

赋值操作：

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

数据存取：

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

大小操作：

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

 

六. queue 容器

1. queue 基本概念

概念：Queue是一种先进先出(First In First Out,FIFO)的数据结构，它有两个出口

队列容器允许从一端新增元素，从另一端移除元素，只有队头和队尾才可以被外界使用

2. queue 常用接口

构造函数：

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

赋值操作：

  • queue& operator=(const queue &que);           //重载等号操作符

数据存取：

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

大小操作：

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

 

七. list容器

1. list基本概念

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

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

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

List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

2.  list构造函数

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

3. list 赋值和交换

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

4. list 大小操作

  • - size();                             //返回容器中元素的个数
  • - empty();                           //判断容器是否为空
  • - resize(num);                   //重新指定容器的长度为num，若容器变长，则以默认值填充新位置。//如果容器变短，则末尾超出容器长度的元素被删除。
  • - resize(num, elem);       //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。//如果容器变短，则末尾超出容器长度的元素被删除。

5. list 插入和删除

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

6. list 数据存取

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

list容器中不可以通过[]或者at方式访问数据

7. list 反转和排序

  • reverse();   //反转链表
  • sort();        //链表排序

 

八. set/ multiset 容器

1. set基本概念

简介：所有元素都会在插入时自动被排序

本质：set/multiset属于关联式容器，底层结构是用二叉树实现。

set和multiset区别：set不允许容器中有重复的元素，multiset允许容器中有重复的元素

2. set构造和赋值

构造：

  • set<T> st;                        //默认构造函数：
  • set(const set &st);       //拷贝构造函数

赋值：

  • set& operator=(const set &st);    //重载等号操作符

set容器插入数据时用insert
set容器插入数据的数据会自动排序

3. set大小和交换

  • size();          //返回容器中元素的数目
  • empty();        //判断容器是否为空
  • swap(s);      //交换两个集合容器

4. set插入和删除

  • insert(elem);           //在容器中插入元素。
  • clear();                    //清除所有元素
  • erase(pos);              //删除pos迭代器所指的元素，返回下一个元素的迭代器。
  • erase(beg, end);    //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
  • erase(elem);            //删除容器中值为elem的元素。

5. set查找和统计

  • find(key);                  //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
  • count(key);                //统计key的元素个数

查找   ---  find    （返回的是迭代器）
统计   ---  count  （对于set，结果为0或者1）

6. set和multiset区别

set不可以插入重复数据，而multiset可以
set插入数据的同时会返回插入结果，表示插入是否成功
multiset不会检测数据，因此可以插入重复数据

7. pair对组创建

描述：成对出现的数据，利用对组可以返回两个数据

两种创建方式：

  • pair<type, type> p ( value1, value2 );
  • pair<type, type> p = make_pair( value1, value2 );

8. set容器排序

主要技术点：利用仿函数，可以改变排序规则

示例一   set存放内置数据类型

  #include <set>
    
    class MyCompare {
    public:
        bool operator()(int v1, int v2) {
            return v1 > v2;
        }
    };
    void test01() {    
        set<int> s1;
        s1.insert(10);
        s1.insert(40);
        s1.insert(20);
        s1.insert(30);
        s1.insert(50);
        //默认从小到大
        for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
            cout << *it << " ";
        }
        cout << endl;
        //指定排序规则
        set<int,MyCompare> s2;
        s2.insert(10);
        s2.insert(40);
        s2.insert(20);
        s2.insert(30);
        s2.insert(50);
    
        for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
            cout << *it << " ";
        }
        cout << endl;
    }
    
    int main() {
        test01();
        system("pause");
        return 0;
    }

利用仿函数可以指定set容器的排序规则

 

九. map/ multimap容器

1. map基本概念

简介：

  • map中所有元素都是pair
  • pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值）
  • 所有元素都会根据元素的键值自动排序

本质：map/multimap属于关联式容器，底层结构是用二叉树实现。

优点：可以根据key值快速找到value值

map和multimap区别：

  • map不允许容器中有重复key值元素
  • multimap允许容器中有重复key值元素

2. map构造和赋值

构造：

  • map<T1, T2> mp;                     //map默认构造函数: 
  • map(const map &mp);             //拷贝构造函数

赋值：

  • map& operator=(const map &mp);    //重载等号操作符

map中所有元素都是成对出现，插入数据时候要使用对组

3. map大小和交换

  • size();          //返回容器中元素的数目
  • empty();        //判断容器是
  • swap(m);      //交换两个map容器

4. map插入和删除

  • insert(elem);           //在容器中插入元素。
  • clear();                    //清除所有元素
  • erase(pos);              //删除pos迭代器所指的元素，返回下一个元素的迭代器。
  • erase(beg, end);    //删除区间[beg,end)的所有元素 ，返回下一个元素的迭代器。
  • erase(key);            //删除容器中值为key的元素。

5. map查找和统计

函数原型：

  • find(key);                  //查找key是否存在,若存在，返回该键的元素的迭代器；若不存在，返回set.end();
  • count(key);                //统计key的元素个数

查找   ---  find    （返回的是迭代器）
统计   ---  count  （对于map，结果为0或者1）

6. map容器排序

目标：map容器默认排序规则为按照key值进行从小到大排序，掌握如何改变排序规则

主要技术点：利用仿函数，可以改变排序规则

    #include <map>
    
    class MyCompare {
    public:
        bool operator()(int v1, int v2) {
            return v1 > v2;
        }
    };
    
    void test01() {
        //默认从小到大排序
        //利用仿函数实现从大到小排序
        map<int, int, MyCompare> m;
    
        m.insert(make_pair(1, 10));
        m.insert(make_pair(2, 20));
        m.insert(make_pair(3, 30));
        m.insert(make_pair(4, 40));
        m.insert(make_pair(5, 50));
    
        for (map<int, int, MyCompare>::iterator it = m.begin(); it != m.end(); it++) {
            cout << "key:" << it->first << " value:" << it->second << endl;
        }
    }
    int main() {
        test01();
        system("pause");
        return 0;
    }

利用仿函数可以指定map容器的排序规则
对于自定义数据类型，map必须要指定排序规则,同set容器
 

 

WISHMELUCK1'
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
STL标准库
Serven的博客
04-20 331
C++的STL标准库
STL标准模板库
糖炒栗子的博客
07-20 5559
STL标准模板库 一。概述 C++内置的标准模板库STL可以分为以下6大类： 1.容器 2.迭代器 3.空间分配器 4.适配器 5.算法 6.仿函数 1.容器： 概念：用来管理一组元素 分类： 序列式容器（Sequence containers）       每个元素都有固定位置－－取决于插入时机和地点，和元素值无关。       vector、deque、list   关联式容器（Associa...
STL标准库详解
weixin_45051519的博客
02-15 2771
STL标准库 主要由容器、迭代器、算法组成 STL主要头文件 <algorithm>、<deque>、<functional>、<iterator>、<vector>、<list>、<map>、<memory>、<numeric>、<queue>、<set>、<stack>、<utility>、<unordered_set>、&lt
STL库 总览
一朵花花送给你、
10-07 740
   STL库1 泛型程序设计2 STL标准模板库2.1 STL库的基本组件2.1.1 STL基本组件----容器2.1.2 STL基本组件----迭代器2.1.3 STL基本组件----函数对象2.1.4 STL基本组件----算法3 迭代器4 容器的基本功能与分类4.1 顺序容器    1 泛型程序设计   泛型程序设计就是时候，将程序设计的尽量的通用。STL标准库就是泛型程序设计的一个很好的范例。   ◇ 编写不依赖具体数据类型的程序；   ◇ 将算法从特定的数据结构中抽象出来，成为通用的；   ◇
《C++语言 - 标准模板库STL》_标准模板库_C++_C++STL_
09-29
在C++编程中，标准模板库（Standard Template Library，简称STL）是一个极其重要的组成部分，它为程序员提供了高效且易用的数据结构和算法。STL是C++标准库的一个核心部分，极大地提升了代码的可读性和复用性，使得...
C++ STL标准模板库-优秀的C++标准库
06-10
STL是Standard Template Library的简称，中文名标准模板库，是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室开发的 ，是一个具有工业强度的，高效的C++库，STL早已是ANSI/ISO C++标准中的一部分。STL...
C++标准库STL源码
03-24
SGI STL是Silicon Graphics Inc.(简称SGI)公司开发的标准模板库(Standard Template Library)的一个版本。它是C++标准库的一个重要实现,对STL的发展和推广产生了重大影响。 SGI STL的源码是开源的,其设计和实现体现...
C++模板与STL库介绍
03-18
接下来，我们讨论C++的STL（Standard Template Library，标准模板库）。STL是C++标准库的一部分，包含了一系列高效的数据结构和算法，如容器、迭代器、算法和函数对象。主要的容器有： 1. **向量(Vector)**：动态...
【C++】——模板初阶 | STL简介
weixin_73551991的博客
02-23 1568
STL是 C++ 标准模板库（Standard Template Library）的缩写。
STL(标准模板库)
热门推荐
m0_60274660的博客
11-29 2万+
概念： STL：标准模板库，是C++标准库的重要组成部分 由概念便可以知道，STL中的所有数据结构都是以模板的方式创建的 LIST--container： list节点： list节点是一个双向指针，实质是一个模板结构体 template<class T> struct _list_node { typedef void* void_pointer; void_pointer prev;//previous void_pointer next;
c++STL中常用模板常用函数记录（新手向）
右边的博客
02-24 4511
vector（不定长数组/向量）： #include  vector vec; vector[0];//使用下标访问元素； vec.front();//取vec中的第一个元素； vec.back();//取vec中的最末一个元素； vec.push_back(x);//在向量末尾加入元素x； vec.pop_back();//删除末尾元素，同时向量空间减少1； vec.inser
STL库基础学习
qq_55168827的博客
04-15 5923
目录 1.什么是STL库 2.几种常见的STL模板 （1）vector 1.vector向量模板 2.vector迭代器 3.常见方法与用法 （2）list （3）queue和stack （4）set和map 3.几种STL 的时间复杂度比较 1.什么是STL库 ◦STL又称为标准模板库，是一套功能强大的 C++ 模板类，提供了通用的模板类和函数，这些模板类和函数可以实现多种流行和常用的算法和数据结构，如向量、链表、队列、栈。 ◦也就是说，有了STL，数据结...
C++ STL常用标准库容器入门（vector,map,set,string,list...）
yuleidnf的博客
08-09 2万+
其中几种种序列容器类型 C++ STL中最基本以及最常用的类或容器无非就是以下几个： string vector deque list forward_list queue priority_queue stack string 对比在C语言中一般怎么使用字符串的 char* s1 = "Hello JackYu!"; //创建指针指向字符串常量，既然是常量字符串，这段字符...
从零开始学C++之STL（一）：STL六大组件简介
Meditation
07-22 9342
一、STL简介 （一）、泛型程序设计 泛型编程（generic programming） 将程序写得尽可能通用 将算法从数据结构中抽象出来，成为通用的 C++的模板为泛型程序设计奠定了关键的基础 （二）、什么是STL 1、STL（Standard Template Library），即标准模板库，是一个高效的C++程序库。 2、包含了诸多在计算机科学领域里常用的
stl标准库
数据挖掘+大数据研发+算法学习
12-01 2726
c++ STL 技巧
C++笔记5•内存管理•
最新发布
qq_64446190的博客
08-12 913
内存管理
STL中的迭代器失效（vector为例）
2302_80190394的博客
08-08 388
STL中的迭代器失效（vector为例）
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WISHMELUCK1'

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值