首页 / C++ / C++常用的STL及方法 (中上)
C++常用的STL及方法 (中上)
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了C++常用的STL及方法 (中上),小编现在分享给大家,供广大互联网技能从业者学习和参考。文章包含13161字,纯文字阅读大概需要19分钟。
内容图文
![C++常用的STL及方法 (中上)](/upload/InfoBanner/zyjiaocheng/599/97255c61fd0d4f81b7887103840779ed.jpg)
前言
C++常用的STL及方法 (上) :
C++常用的 STL 及方法 (中) :
C++常用的 STL 及方法 (中下) :
C++常用的 STL 及方法 (下) :
目录
forward_list
forward_list 是一种顺序容器, 其可大致看作是单向链表, 和 <vector>, <string>, <deque>, <array> 不同的是, 单向链表容器不能通过下标来访问元素, 且在对元素进行操作的方式也有所不同, 只能插入和删除后继元素. 优点是在插入和删除操作方面速度较快.缺点是访问元素较为麻烦, 需要从第一个元素开始遍历.
关于迭代器
注意迭代器 .before_begin() 指的是头结点, 头结点无元素因此不能解引用. 而 .begin() 才是指向第一个元素的迭代器.
详见 : https://www.cnblogs.com/ICeVe/p/14527347.html
.empty()
用途 : 判断单向链表是否为空. 如果为空返回 1, 否则返回 0
一般形式 :
forward_list<typename>FL.empty();
/* typename 为类型名, 包含容器类型和数据类型. FL 为自定义的标识符. 返回类型为 bool */
#include <iostream>
#include <forward_list>
using namespace std;
int main(void)
{
forward_list<int> FL;
cout << FL.empty() << endl;
return 0;
}
输出结果
1
.insert_after()
用途 : 在某个元素后 (需要从第一个元素开始遍历) 插入单个或多个后继元素. 插入时注意容器类型和数据类型.
一般形式 :
forward_list<typename>FL.insert_after(iterator, x);
/* typename 为类型名, 包含容器类型与数据类型. FL 为自定义的标识符. iterator 为迭代器, x 为插入的变量或常量. 这里是在某个位置之后插入单个元素, 返回一个指向新插入元素的迭代器*/
forward_list<typename>FL.insert_after(iterator, n, x);
/* n 为数量. 这里是将 n 个 x 插入到某个位置之后. 返回一个指向最后插入的元素的迭代器*/
forward_list<typename>FL.insert_after(iterator, begin, end);
/* begin 和 end 限定范围. 这里是将一部分元素插入到某个位置之后. 返回一个指向最后插入的元素的迭代器*/
#include <iostream>
#include <forward_list>
using namespace std;
int main(void)
{
forward_list<int> FL1{1, 2, 3, 4, 5};
forward_list<int> FL2{6, 7, 8, 9, 10};
FL1.insert_after(FL1.before_begin(), 0);
for (auto i = FL1.begin(); i != FL1.end(); i++) /*从 FL1 的第一个元素开始遍历*/
{
if (*i == 5)
FL1.insert_after(i, FL2.begin(), FL2.end());
}
for (auto i = FL1.begin(); i != FL1.end(); i++) /*从 FL1 的第一个元素开始遍历*/
{
if (*i == 10)
FL1.insert_after(i, 10, 1);
}
for (auto i : FL1)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
0 1 2 3 4 5 6 7 8 9 10 1 1 1 1 1 1 1 1 1 1
.erase.after()
用途 : 删除某个位置后的单个或多个后继元素
一般形式 :
forward_list<typename>FL.erase(iterator);
/* typename 为类型名, 其中包含容器类型和数据类型. FL 为自定义标识符. 返回一个指向删除元素的后一个位置的迭代器*/
forward_list<typename>FL.erase(begin, end);
/* 删除一部分元素. FL 为自定义标识符. 返回指向最后一个被删除元素的后一个位置的迭代器*/
#include <iostream>
#include <forward_list>
using namespace std;
int main(void)
{
forward_list<int> FL{1, 2, 3, 4, 5};
for (auto i = FL.begin(); i != FL.end(); i++)
{
if (*i == 2)
FL.erase_after(i);
}
for (auto i : FL)
cout << i << ' ';
cout << endl;
for (auto i = FL.begin(); i != FL.end(); i++)
{
if (*i == 2)
FL.erase_after(i, FL.end());
}
for (auto i : FL)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
1 2 4 5
1 2
.clear()
用途 : 清空单向链表
一般形式 :
forward_list<typename>FL.clear();
/* typename 为类型名, 其中包含容器类型和数据类型. FL 为自定义标识符. 返回类型为 bool */
#include <iostream>
#include <forward_list>
using namespace std;
int main(void)
{
forward_list<int> FL{1, 2, 3, 4, 5};
FL.clear();
cout << FL.empty() << endl;
return 0;
}
输出结果
1
.swap()
用途 : 交换两个单向链表的元素. 交换时注意容器类型和数据类型
一般形式 :
forward_list<typename>FL1.swap(FL2);
/* typename 为类型名, 其中包含容器类型和数据类型. FL1 和 FL2 为自定义标识符. 返回类型为 void */
#include <iostream>
#include <forward_list>
using namespace std;
int main(void)
{
forward_list<int> FL1{1, 2, 3, 4, 5};
forward_list<int> FL2{6, 7, 8, 9, 10};
FL1.swap(FL2);
for(auto i : FL1)
cout << i << ' ';
cout << endl;
for(auto i : FL2)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
6 7 8 9 10
1 2 3 4 5
.pop_front()
用途 : 删除头结点的后继元素
一般形式 :
forward_list<typename>FL.popfront();
/* typename 为类型名, 其中包含容器类型和数据类型. FL 为自定义的标识符. 返回类型为 void */
#include <iostream>
#include <forward_list>
using namespace std;
int main(void)
{
forward_list<int> FL{1, 2, 3, 4, 5};
FL.pop_front();
for(auto i : FL)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
2 3 4 5
.push_front()
用途 : 在头结点插入后继元素
一般形式 :
forward_list<typename>FL.push_front(x);
/* typename 为类型名, 其中包含容器类型和数据类型. FL 为自定义标识符, x 为插入的变量或常量. 返回类型为 void */
#include <iostream>
#include <forward_list>
using namespace std;
int main(void)
{
forward_list<int> FL{1, 2, 3, 4, 5};
FL.push_front(0);
for(auto i : FL)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
0 1 2 3 4 5
.max_size()
用途 : 求出单向链表能容纳的最大元素数量.
一般形式 :
forward_list<typename>FL.max_size();
/* typename 为类型名, 其中包含容器类型和数据类型. FL 为自定义标识符. 返回类型为 size_t */
#include <iostream>
#include <forward_list>
using namespace std;
int main(void)
{
forward_list<int> FL;
cout << FL.max_size() << endl;
return 0;
}
输出结果
1152921504606846975
distance()
由于 forward_list 不能求出链表中已容纳的元素个数. 因此需要 STL <iterator> 中的 distance 函数来求出元素个数.
用途 : 求出两个迭代器之间的距离
一般形式 :
distance(begin, end);
/*原理是通过两个迭代器相减得到的距离数作为元素个数.*/
#include <iostream>
#include <forward_list>
#include <iterator>
using namespace std;
int main(void)
{
forward_list<int> FL{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
cout << distance(FL.begin(), FL.end()) << endl;
return 0;
}
输出结果
10
list
list 是一种顺序容器, 大概可以看成是一种双向链表. 支持大部分操作, 访问元素不能通过下标访问. 优点是插入删除操作速度较快.
.empty()
用途 : 判断双向链表知否为空. 如果为空返回 1, 否则返回 0.
一般形式 :
list<typename>L.empty();
/* typename 为类型名, 其中包括容器类型和数据类型. L 为自定义的标识符. 返回类型为 bool */
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L;
cout << L.empty() << endl;
return 0;
}
输出结果
1
.clear()
用途 : 清空双向链表
一般形式 :
list<typename>L.clear();
/* typename 为类型名, 其中包含容器类型和数据类型. L 为自定义的标识符. 返回类型为 void */
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L{1, 2, 3, 4, 5, 6};
L.clear();
cout << L.empty() << endl;
return 0;
}
输出结果
1
.swap()
用途 : 交换两个双向链表的元素. 交换时注意容器类型和数据类型
一般形式 :
list<typename>L1.swap(L2);
/* typename 为类型名, 其中包含容器类型和数据类型. L1 和 L2 为自定义标识符. 返回类型为 void */
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L1{1, 2, 3, 4, 5};
list<int> L2{6, 7, 8, 9, 10};
L1.swap(L2);
for(auto i : L1)
cout << i << ' ';
cout << endl;
for(auto i : L2)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
6 7 8 9 10
1 2 3 4 5
.size()
用途 : 求出双向链表中的元素个数.
一般形式 :
list<typename>L.size();
/* typename 为类型名, 其中包含容器类型和数据类型. L 为自定义标识符. 返回类型为 size_t*/
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L{1, 2, 3, 4, 5};
cout << L.size() << endl;
return 0;
}
输出结果
5
.max_size()
用途 : 求出双向链表能容纳的最大元素数量.
一般形式 :
list<typename>L.max_size();
/* typename 为类型名, 其中包含容器类型和数据类型. L 为自定义标识符. 返回类型为 size_t*/
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L;
cout << L.max_size() << endl;
return 0;
}
输出结果
768614336404564650
.push_back()
用途 : 在双向链表尾部插入元素. 插入时注意容器类型和数据类型
一般形式 :
list<typename>L.push_back(x);
/* typename 类型名, 其中包含容器类型和数据类型. L 为自定义标识符, x 为插入的变量或常量. 返回类型为 void */
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L{1, 2, 3, 4};
L.push_back(5);
for(auto i : L)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
1 2 3 4 5
.push_front()
用途 : 在双向链表头部插入元素. 插入时注意容器类型和数据类型
一般形式 :
list<typename>L.push_front(x);
/* typename 为类型名, 其中包含容器类型和数据类型. L 为自定义标识符, x 为插入的变量或常量. 返回类型为 void */
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L{2, 3, 4, 5};
L.push_front(1);
for(auto i : L)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
1 2 3 4 5
.insert()
用途 : 在双向链表中的某一位置前插入单个或多个元素. 插入时注意容器类型和数据类型
一般形式 :
list<typename>L.insert(iterator, x);
/* typename 为类型名, 其中包含容器类型和数据类型. L 为自定义的标识符, x 为插入的变量或常量. iterator 为迭代器. 返回一个指向新插入元素的迭代器*/
list<typename>L.insert(iterator, n, x);
/* n 为插入元素的个数. 这里是指将 n 个 x 插入到某位置之前. 返回一个指向第一个被插入元素的迭代器*/
list<typename>L.insert(iterator, begin, end);
/*这里是指将一部分元素插入到某位置之前. 返回一个指向第一个被插入元素的迭代器*/
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L1{1, 2, 3, 4, 5};
list<int> L2{6, 7, 8, 9, 10};
L1.insert(L1.begin(), 0);
L2.insert(L2.end(), 10, 1);
L1.insert(L1.end(), L2.begin(), L2.end());
for(auto i : L1)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
0 1 2 3 4 5 6 7 8 9 10 1 1 1 1 1 1 1 1 1 1
.pop_back()
用途 : 删除尾元素
一般形式 :
list<typename>L.pop_back();
/* typename 为类型名, 其中包含容器类型和数据类型. L 为自定义的标识符. 返回类型为 void */
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L{1, 2, 3, 4, 5};
L.pop_back();
for(auto i:L)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
1 2 3 4
.pop_front()
用途 : 删除头元素
一般形式 :
list<typename>L.pop_front();
/* typename 为类型名, 其中包含容器类型和数据类型. L 为自定义标识符. 返回类型为 void */
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L{1, 2, 3, 4, 5};
L.pop_front();
for(auto i:L)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
2 3 4 5
.erase()
用途 : 删除双向链表中单个或多个元素.
一般形式 :
list<typename>L.erase(iterator);
/* typename 为类型名, 其中包含容器类型和数据类型. L 为自定义标识符, iterator 为迭代器. 返回一个被删除元素之后的位置的迭代器*/
list<typename>L.erase(begin, end);
/* 删除一部分元素. 返回一个被删除元素之后的位置的迭代器*/
#include <iostream>
#include <list>
using namespace std;
int main(void)
{
list<int> L{1, 2, 3, 4, 5};
L.erase(L.begin());
for(auto i : L)
cout << i << ' ';
cout << endl;
L.erase(L.begin(), L.end());
cout << L.empty() << endl;
return 0;
}
输出结果
2 3 4 5
1
array
array是C++的数组容器, 不同于 <vector>, <string>, <deque> 的是 array 的大小是固定的, 不能执行元素的插入和删除操作. 其优点是访问元素速度较快
.empty()
用途 : 判断数组是否为空. 如果为空返回 1, 否额返回 0
一般形式 :
array<typename, n>A.empty();
/* typename 类型名, 其中包含容器类型和数据类型. A 为自定义的标识符, n 为数组的大小. 返回类型为 bool */
#include <iostream>
#include <array>
using namespace std;
int main(void)
{
array<int, 10> A;
cout << A.empty() << endl;
return 0;
}
输出结果
1
.size()
用途 : 求出数组的元素个数 (严格来说这里应该是数组的大小)
一般形式 :
array<typename, n>A.size();
/* typename 为类型名, 其中包含容器类型和数据类型. A 为自定义的标识符, n 为数组的大小. 返回类型为 size_t */
#include <iostream>
#include <array>
using namespace std;
int main(void)
{
array<int, 10> A{1, 2, 3, 4, 5};
cout << A.size() << endl;
return 0;
}
输出结果
10
.max_size()
用途 : 求出数组所能容纳的最大元素数量. (在 array 中一般来说设置的数组大小就是最大元素数量)
一般形式 :
array<typename, n>A.max_size();
/* typename 为类型名, 其中包含容器类型和数据类型. A 为自定义的标识符, n 为设置的数组大小. 返回类型为 size_t */
#include <iostream>
#include <array>
using namespace std;
int main(void)
{
array<int, 10> A;
cout << A.max_size() << endl;
return 0;
}
输出结果
10
.swap()
用途 : 交换两个数组的元素. 交换时注意元素的容器类型和数据类型
一般形式 :
array<typename, n>A1.swap(A2);
/* typename 为类型名, 其中包含容器类型和数据类型. A1 为定义的标识符, n 为数组的大小. 返回类型为 void */
#include <iostream>
#include <array>
using namespace std;
int main(void)
{
array<int, 10> A1{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
array<int, 10> A2{11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
A1.swap(A2);
for (auto i : A1)
cout << i << ' ';
cout << endl;
for (auto i : A2)
cout << i << ' ';
cout << endl;
return 0;
}
输出结果
11 12 13 14 15 16 17 18 19 20
1 2 3 4 5 6 7 8 9 10
内容总结
以上是互联网集市为您收集整理的C++常用的STL及方法 (中上)全部内容,希望文章能够帮你解决C++常用的STL及方法 (中上)所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错,欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 gblab@vip.qq.com 举报,一经查实,本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。