时间戳

首页 > 技术文章 > C++常用的STL及方法 (上)

C++常用的STL及方法 (上)

ICeVe 2021-03-13 18:57 原文

前言

 
由于 C++ 的复杂和多样性, 因此为了方便查找和使用, 很多STL有重复的部分.建议在使用这些 STL 前先点击 STL 查看其简要描述, 然后再去查看 STL 中提供的方法
 
STL 中没出现的方法是因为这些方法不常用或无法使用 (例如 vector 不能用 .push_front() 等)

 

由于内容过多, 因此分了 上, 中上, 中, 中下, 下 五篇博文完成.

 

C++常用的 STL 及方法 (中上) :

C++常用的 STL 及方法 (中) :

C++常用的 STL 及方法 (中下) :

C++常用的 STL 及方法 (下) :

 

目录

 

C++ ( C++ 11 )

 

本文中由于一些 STL 和方法在 C++11 及更高标准中才能使用. 因此如果编译器支持的 C++ 标准过低 (如 vc6.0 等只支持 C++98 标准), 建议更换编译器 (建议使用 g++, clang, visual studio 2013及更高版本, dev-cpp 等)
 

这里提一句, 如果使用 dev-cpp的话需要在编译器中进行设置, 具体做法是点击工具 ---> 编译选项 ---> 编译器窗口下点击"编译时加入以下命令" ---> 填入小写的 -std=c++11 然后点击确定即可. dev-cpp的版本最好是5.11及以上

 

STL -- 容器

 

容器分为顺序容器与关联容器, 本文从<vector>到<pair>前为顺序容器, <pair>到<set>为关联容器. 主要区别在于关联容器通过关键词来访问元素, 而顺序容器通过位置访问元素.

 

关于迭代器

 

所有顺序容器或者是关联容器, 最常见的两种迭代器就是 .begin() 和 .end(). 这里姑且可以看成是指针. 前者指向第一个元素, 后者指向尾元素的后一个位置.
 
大部分标准容器迭代器都支持的操作 :

迭代器 解释
*iterator 对迭代器解引用
iterator->m 解引用迭代器并访问成员
++iterator, iterator++ 迭代器指向下一个元素
--iterator, iterator-- 迭代器指向上一个元素 (forwar_list容器不适用)
iterator1 == iterator2 判断
iterator1 != iterator2 判断

 

只有<vector>, <string>, <deque>, <array>迭代器支持的操作 :

迭代器 解释
iterator + n 迭代器向下移动了 n 个元素
iterator - n 迭代器向上移动了 n 个元素
iterator += n 迭代器向上移动的复合语句
iterator -= n 迭代器向下移动的复合语句
iterator1 - iterator2 两迭代器相减所得的距离
>, >=, <, <= 迭代器位置比较, 一般来说迭代器越往后越大

 

类似数组的容器 : vector, string, deque, array

类似链表的容器 : list, forward_list

 

 

vector

 

vector 是一种顺序容器, 大致可看成一种大小可变的数组, 优点是访问速度快, 但是在尾部之外插入或删除元素速度较慢. 支持大部分操作, 不能在首元素前插入元素. 支持下标访问元素.

 

关于多维vector, array, deque, string请点击 : https://www.cnblogs.com/ICeVe/p/14354926.html

 

 

.empty()

 

用途 : 查看vector是否为空. 如果为空返回 1 否则为 0

一般形式 :

vector<typename>V.empty();	

/* typename 意为类型名, 其中包括容器类型和数据类型. V 为自定义的标识符. 返回类型为 bool */

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V1;
    vector<int> V2{1, 2, 3};

    cout << V1.empty() << endl;
    cout << V2.empty() << endl;

    return 0;
}

 

输出结果

1
0

 

 

 

.size()

 

用途 : 求vector中有多少个元素.

一般形式 :

vector<typename>V.size();	

/* typename 意为类型名, 其中包括容器类型和数据类型. V 为自定义的标识符. 返回类型为 site_t */

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V{1, 2, 3};

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

    return 0;
}

 

输出结果

3

 

 

 

.max_size()

 

用途 : 求vector能容纳的最大元素数量

一般形式 :

vector<typename>V.max_size();	

/* typename 意为类型名, 其中包括容器类型和数据类型. V 为自定义的标识符. 返回类型为 site_t */

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V;

    cout << V.max_size() << endl;

    return 0;
}

 

输出结果

4611686018427387903

 

 

 

.push_back()

 

用途 : 在vector尾部插入一个元素. 插入前注意元素的容器类型和数据类型

一般形式 :

vector<typename>V.pushback(x);	

/* typename 意为类型名, 其中包括容器类型和数据类型. V 为自定义的标识符, x 为变量或常量. 返回类型为 void */

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V;

    V.push_back(1);

    cout << V[0] << endl;

    return 0;
}

 

输出结果

1

 

 

 

.insert()

 

用途 : 在vector中某一处前插入单个或多个元素. 插入时注意元素的容器类型和数据类型

一般形式 :

vector<typename>V.insert(iterator, x);	

/* typename 意为类型名, 其中包括容器类型和数据类型. V 为自定义的标识符, iterator 为迭代器, x 为变量或常量. 返回一个指向新插入元素的迭代器. */

vector<typename>V.insert(iterator, n, x);

/* n 为插入的数量,  这里意思是在哪个位置前插入 n 个 x . 返回一个指向新插入的第一个元素的迭代器*/

vector<typename>V.insert(iterator, begin, end);

/* begin 和 end 限定范围, 意为将一部分元素插入到某个位置前. 返回一个指向新插入的第一个元素的迭代器*/

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V1{1, 2, 3, 4, 5};
    vector<int> V2{6, 7, 8, 9, 10};

    V1.insert(V1.begin(), 0);   /*在 V1 的第一个位置插入1*/
    V1.insert(V1.end(), V2.begin(), V2.end());  /*将整个 V2 插入到 V1 的末尾来 */
    V1.insert(V1.end(), 10, 0); /*在 V1 末尾插入10个0*/

    for (auto i : V1)
        cout << i << ' ';

    cout << endl;

    return 0;
}

 

输出结果

0 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0 0 0 0 0 0

 

 

 

.erase()

 

用途 : 删除vector中单个或多个元素

一般形式 :

vector<typename>V.erase(iterator);

/*typename意为类型名, 其中包括容器类型和数据类型. V为自定义的标识符, iterator为迭代器. 返回一个指向删除元素的后一个位置的迭代器*/

vector<typename>V.erase(begin, end);

/*删除 begin 和 end 限定范围内的所有元素. 返回一个指向最后删除元素的后一个位置的迭代器*/

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V1{1, 2, 3, 4, 5};

    V1.erase(V1.begin() + 3);

    for (auto i : V1)
        cout << i << ' ';
    cout << endl;

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

    for (auto i : V1)
        cout << i << ' ';

    cout << V1.empty() << endl;

    return 0;
}

 

 

.clear()

 

用途 : 清空vector

一般形式 :

vector<typename>V.clear();

/* typename 意为类型名, 其中包含容器类型和数据类型. 返回类型为 void */

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V{1, 2, 3, 4, 5};

    V.clear();

    for (auto i : V)
        cout << i << ' ';

    cout << V.empty() << endl;

    return 0;
}

 

输出结果

1

 

 

 

.swap()

 

用途 : 交换两个 vector 的元素, 交换时注意元素的容器类型和数据类型

一般形式 :

vector<typename>V1.swap(V2);

/* typename 为类型名, 其中包含容器类型和数据类型. V1, V2 为自定义的标识符. 返回类型为 void */

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V1{1, 2, 3, 4, 5};
    vector<int> V2{6, 7, 8, 9, 10};

    V1.swap(V2);

    for (auto i : V2)
        cout << i << ' ';

    cout << endl;

    return 0;
}

 

输出结果

1 2 3 4 5

 

 

 

.pop_back()

 

用途 : 删除 vector 的尾元素.

一般形式 :

vector<typename>V.pop_back();

/* typename 为类型名, 包含容器类型和数据类型. V 为自定义的标识符. 返回类型为 void */

 

#include <iostream>
#include <vector>

using namespace std;

int main(void)
{
    vector<int> V{1, 2, 3, 4, 5};

    V.pop_back();

    for(auto i : V)
        cout << i << ' ';

    cout << endl;

    return 0;
}

 

输出结果

1 2 3 4

 

 

 

string

 

string 是 C++ 中用来处理字符串的 STL , 大致可看成一种大小可变的字符数组. 支持大部分操作, 不能在首元素前插入元素. 支持下标访问字符.

 

关于多维vector, array, deque, string请点击 : https://www.cnblogs.com/ICeVe/p/14354926.html

 

 

.empty()

 

用途 : 检查字符串是否为空. 如果为空返回 1, 否则返回 0.

一般形式 :

string str.empty();

/* str 为自定义的标识符. 返回类型为 bool */

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str;

    cout << str.empty() << endl;

    return 0;
}

 

输出结果

1

 

 

 

.size()

 

用途 : 求字符串有多少字符

一般形式 :

string str.size();

/* str 为自定义的标识符. 返回类型为 size_t */

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str{"Hello, World!"};

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

    return 0;
}

 

输出结果

13

 

 

 

.max_size()

 

用途 : 求字符串能容纳的最大字符数量.

一般形式 :

string str.max_size();

/* str 为自定义的标识符.  返回类型为 size_t */

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str;

    cout << str.max_size() << endl;

    return 0;
}

 

输出结果

9223372036854775807

 

 

 

getline()

 

用途 : 读取字符串. 读取到换行符停止读取 (读取时会丢掉换行符).

一般形式 :

getline(cin, str);

/* cin 是输入流, str 是自定义的字符串标识符. 这里是将从 cin 输入获取到的字符串待读入 str 中. 返回一个 istream 流参数*/

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str;

    getline(cin, str);  /*输入Hello, World!*/

    cout << str << endl;

    return 0;
}

 

输出结果

Hello, World!

 

 

 

.push_back()

 

用途 : 在字符串末尾插入一个字符

一般形式 :

string str.pushback(x);

/* str 为自定义标识符, x 为插入的字符. 返回类型为 void */

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str{"Hello, World"};

    str.push_back('!');

    cout << str << endl;

    return 0;
}

 

输出结果

Hello, World!

 

 

 

.insert()

 

用途 : 在字符串的某个位置前插入单个或多个字符.

一般形式 :

string str.insert(iterator, x);

/* str 为自定义的标识符, iterator 为迭代器, x 为插入的字符. 返回一个指向新插入字符的迭代器*/

string str.insert(iterator, n, x);

/* n 为插入字符的数量. 意为在字符串中的某个位置前插入 n 个 x 字符. 返回一个指向新插入的第一个字符的迭代器*/

string str.insert(interator, begin, end);

/* begin 和 end 限定范围, 意为将一部分字符插入到某个位置前. 返回一个指向新插入的第一个元素的迭代器*/

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str1{"Hello"};
    string str2{"World!"};

    str1.insert(str1.end(), ',');
    str1.insert(str1.end(), str2.begin(), str2.end());
    str1.insert(str1.end(), 10, '!');

    cout << str1 << endl;

    return 0;
}

 

输出结果

Hello,World!!!!!!!!!!!

 

 

 

.erase()

 

用途 : 删除字符串中的单个或多个字符

一般形式 :

string str.erase(iterator);

/* str 为自定义的标识符, iterator 为迭代器, 这里是将字符串中的某个字符删除. 返回一个指向删除元素的后一个位置迭代器*/

string str.erase(begin, end);

/* 删除 begin 和 end 所限制的范围内的字符. 返回一个指向最后元素被删除的后一个位置的迭代器*/

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str{"Hello, World!"};

    str.erase(str.begin());
    cout << str << endl;
    str.erase(str.begin(), str.end());
    cout << str.empty() << endl;

    return 0;
}

 

输出结果

ello, World!
1

 

 

 

.clear()

 

用途 : 清空字符串

一般形式 :

string str.clear();

/* str 为自定义标识符. 返回类型为 void */

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str{"Hello, World!"};

    str.clear();

    cout << str.empty() << endl;

    return 0;
}

 

输出 结果

1

 

 

 

.swap()

 

用途 : 交换两个字符串的字符.

一般形式 :

string str1.swap(str2);

/* str1 和 str 2 为自定义标识符. 返回类型为 void */

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str1{"Hello, World!"};
    string str2{"World!Hello, "};

    str1.swap(str2);

    cout << str1 << endl;
    cout << str2 << endl;

    return 0;
}

 

输出结果

World!Hello,
Hello, World!

 

 

 

.pop_back()

 

用途 : 删除尾字符

一般形式 :

string str.pop_back();

/* str 为自定义的标识符. 返回类型为 void */

 

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string str{"Hello, World!"};

    str.pop_back();

    cout << str << endl;

    return 0;
}

 

输出结果

Hello, World

 

 

 

deque

 

deque 是一种顺序容器, 大致可看成是大小可变的双向队列, 支持大部分操作. 在任何位置进行插入/删除操作都很快. 支持下标访问

 

关于多维vector, array, deque, string请点击 : https://www.cnblogs.com/ICeVe/p/14354926.html

 

 

.empty()

 

用途 : 检查deque是否为空. 如果为空返回 1, 否则返回 0

一般形式 :

deque<typename>D.empty();

/* typename 为类型名, 其中包括容器类型和数据类型. D 为自定义的标识符. 返回类型为 bool */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D;

    cout << D.empty() << endl;

    return 0;
}

 

输出结果

1

 

 

 

.size()

 

用途 : 求出deque所含的元素个数

一般形式 :

deque<typename>D.size();

/* typename 为类型名, 其中包括容器类型和数据类型. D 为自定义的标识符. 返回类型为 size_t */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D{1, 2, 3, 4, 5};

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

    return 0;
}

 

输出结果

5

 

 

 

.max_size()

 

用途 : 求出deque所能包含的最大元素数量.

一般形式 :

deque<typename>D.max_size();

/* typename 为类型名, 其中包含容器类型和数据类型. D 为自定义的标识符. 返回类型为 size_t */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D;

    cout << D.max_size() << endl;

    return 0;
}

 

输出结果

4611686018427387903

 

 

 

.push_back()

 

用途 : 在deque尾部插入元素, 插入时注意元素的容器类型和数据类型.

一般形式 :

deque<typename>D.push_back(x);

/* typename 为类型名, 其中包括容器类型和数据类型. D 为自定义的标识符, x 为要插入的变量或常量. 返回类型为 void */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D;

    D.push_back(1);
    D.push_back(2);

    for( auto i : D)
        cout << i << ' ';

    cout << endl;

    return 0;
}

 

输出结果

1 2

 

 

 

.push_front()

 

用途 : 在deque头部插入元素, 插入时注意元素的容器类型和数据类型

一般形式 :

deque<typename>D.push_front(x);

/* typename 为类型名, 其中包括容器类型和数据类型. D 为自定义的标识符, x 为插入的变量或常量. 返回类型为 void */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D;

    D.push_front(1);
    D.push_front(2);

    for (auto i : D)
        cout << i << endl;

    return 0;
}

 

输出结果

2
1

 

 

 

.insert()

 

用途 : 在deque的某一处前插入单个或多个元素. 插入时注意元素的容器类型和数据类型

一般形式 :

deque<typename>D.insert(iterator, x);

/* typename 为类型名, 其中包括容器类型和数据类型. D 为自定义的标识符, iterator 为迭代器, x 为插入的变量或常量. 这里是在容器的某个位置前插入一个元素. 返回一个指向新插入的元素的迭代器*/

deque<typename>D.insert(iterator, n, x);

/* n 为个数. 这里是指在容器的某个位置前插入 n 个 x. 返回一个为指向新插入的第一个元素的迭代器*/

deque<typename>D.insert(iterator, begin, end);

/* begin 和 end 限定范围. 这里是指将一部分元素插入到某个位置前. 返回一个指向新插入的第一个元素的迭代器*/

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D1{1, 2, 3, 4, 5};
    deque<int> D2{6, 7, 8, 9, 10};

    D1.insert(D1.begin(), 0);
    D1.insert(D1.begin(), D2.begin(), D2.begin());
    D1.insert(D1.end(), 10, 1);

    for (auto i : D1)
        cout << i << ' ';

    cout << endl;

    return 0;
}

 

输出结果

0 1 2 3 4 5 1 1 1 1 1 1 1 1 1 1

 

 

 

.erase()

 

用途 : 删除deque中的单个或多个元素.

一般形式 :

deque<typename>D.erase(iterator);

/* typename 为类型名, 其中包含容器类型和数据类型. iterator 为迭代器. 这是将容器中的某个元素删除. 返回一个指向删除元素的后一个位置的迭代器*/

deque<typename>D.erase(begin, end);

/*这里是将容器中的一部分元素删除. 返回一个指向最后元素被删除的后一个位置的迭代器*/

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D{1, 2, 3, 4, 5};

    D.erase(D.end() - 1);
    for (auto i : D)
        cout << i << ' ';
    cout << endl;
    D.erase(D.begin(), D.end());
    cout << D.empty() << endl;

    return 0;
}

 

输出结果

1 2 3 4
1

 

 

 

.clear()

 

用途 : 清空容器

一般形式 :

deque<typename>D.clear();

/* typename 为类型名, 其中包含容器类型和数据类型. D 为自定义的标识符. 返回类型为 void */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D{1, 2, 3, 4, 5};

    D.clear();

    cout << D.empty() << endl;

    return 0;
}

 

输出结果

1

 

 

 

.swap()

 

用途 : 交换两个deque的元素. 交换时注意元素的容器类型和数据类型.

一般形式 :

deque<typename>D1.swap(D2);

/* typename 为类型名, 其中包含容器类型和数据类型. D1 和 D2 为自定义的标识符. 返回类型为 void */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D1{1, 2, 3, 4, 5};
    deque<int> D2{5, 4, 3, 2, 1};

    D1.swap(D2);

    for(auto i : D1)
        cout << i << ' ';
    cout << endl;

    for(auto i : D2)
        cout << i << ' ';
    cout << endl;

    return 0;
}

 

输出结果

5 4 3 2 1
1 2 3 4 5

 

 

 

.pop_back()

 

用途 : 删除尾元素

一般形式 :

deque<typename>D.pop_back();

/* typename 为类型名, 其中包含容器类型和数据类型. D 为自定义的标识符. 返回类型为 void */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D{1, 2, 3, 4, 5};

    D.pop_back();

    for(auto i : D)
        cout << i << ' ';

    cout << endl;

    return 0;
}

 

输出结果

1 2 3 4

 

 

 

.pop_front()

 

用途 : 删除头元素

一般形式 :

deque<typename>D.pop_front();

/* typename 为类型名, 其中包含容器类型和数据类型. D 为自定义标识符. 返回类型为 void */

 

#include <iostream>
#include <deque>

using namespace std;

int main(void)
{
    deque<int> D{1, 2, 3, 4, 5};

    D.pop_front();

    for(auto i : D)
        cout << i << ' ';

    cout << endl;

    return 0;
}

 

输出结果

2 3 4 5

 

 

 

参考:

 

  1. <<算法笔记>> -- 胡凡, 曾磊
  2. <<C++ Primer>> -- Stanley B. Lippman

推荐阅读