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

时间：2021-03-14 00:06:20 阅读：35 评论：0 收藏：0 [点我收藏+]

前言

?
由于 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等)

STL -- 容器

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

关于迭代器

所有顺序容器或者是关联容器, 最常见的两种迭代器就是 .begin() 和 .end(). 这里姑且可以看成是指针. 前者指向第一个元素, 后者指向尾元素的后一个位置.
顺序容器中只有类似数组的容器迭代器可以使用一些运算 (如 ++, --等), 而类似链表的容器迭代器不能使用这些运算

类似数组的容器 : 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 意为类型名, 其中包括STL和数据类型. 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 意为类型名, 其中包括STL和数据类型. 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;
}

输出结果

.max_size()

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

一般形式 :

vector<typename>V.max_size();	

/* typename 意为类型名, 其中包括STL和数据类型. 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尾部插入一个元素. 插入前注意元素的数据类型或STL

一般形式 :

vector<typename>V.pushback(x);	

/* typename 意为类型名, 其中包括STL和数据类型. 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;
}

输出结果

.insert()

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

一般形式 :

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

/* typename 意为类型名, 其中包括 STL 和数据类型. 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意为类型名, 其中包括STL和数据类型. 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 意为类型名, 其中包含 STL 和数据类型. 返回类型为 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;
}

输出结果

.swap()

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

一般形式 :

vector<typename>V1.swap(V2);

/* typename 为类型名, 其中包含 STL 和数据类型. 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 为类型名, 包含 STL 和数据类型. 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;
}

输出结果

.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;
}

输出结果

.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;
}

输出结果

.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()

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

一般形式 :

deque<typename>D.empty();

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

#include <iostream>
#include <deque>

using namespace std;

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

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

    return 0;
}

输出结果

.size()

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

一般形式 :

deque<typename>D.size();

/* typename 为类型名, 其中包括 STL 和数据类型. 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;
}

输出结果

.max_size()

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

一般形式 :

deque<typename>D.max_size();

/* typename 为类型名, 其中包含 STL 和数据类型. 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()

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

一般形式 :

deque<typename>D.push_back(x);

/* typename 为类型名, 其中包括 STL 和数据类型. 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<typename>D.push_front(x);

/* typename 为类型名, 其中包括 STL 和数据类型. 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<typename>D.insert(iterator, x);

/* typename 为类型名, 其中包括 STL 和数据类型. 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<typename>D.erase(iterator);

/* typename 为类型名, 其中包含 STL 和数据类型. 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 为类型名, 其中包含 STL 和数据类型. 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;
}

输出结果

.swap

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

一般形式 :

deque<typename>D1.swap(D2);

/* typename 为类型名, 其中包含 STL 和数据类型. 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 为类型名, 其中包含 STL 和数据类型. 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 为类型名, 其中包含 STL 和数据类型. 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

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

原文：https://www.cnblogs.com/ICeVe/p/14527347.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)

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

前言

目录

C++ ( C++ 11 )

STL -- 容器

关于迭代器

vector

.empty()

.size()

.max_size()

.push_back()

.insert()

.erase()

.clear()

.swap()

.pop_back()

string

.empty()

.size()

.max_size()

getline()

.push_back()

.insert()

.erase()

.clear()

.swap()

.pop_back()

deque

.empty()

.size()

.max_size()

.push_back()

.push_front()

.insert()

.erase()

.clear()

.swap

.pop_back()

.pop_front()