ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 编程语言> 文章详细

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

2021-04-10 16:01:10  阅读：128  来源： 互联网

标签：常用 end 迭代 STL void begin C++ int include


前言

 

C++常用的STL及方法 (上) : https://www.cnblogs.com/ICeVe/p/14527347.html

C++常用的 STL 及方法 (中上) : https://www.cnblogs.com/ICeVe/p/14531259.html

C++常用的 STL 及方法 (中) : https://www.cnblogs.com/ICeVe/p/14533812.html

C++常用的 STL 及方法 (中下) : https://www.cnblogs.com/ICeVe/p/14535257.html

 

目录

 

STL -- 泛型算法

 

C++中的 <algorithm> 提供了非常多的算法, 使用这些算法能极大的提高编程效率.

 

 

algorithm

 

algorithm 中提供的算法大多数对迭代器有要求, 且需要 STL <iterator> 的支持. 下面来介绍几种常见的迭代器类型.

 

迭代器大致可分为 5 类 :

 

 

输入迭代器

 

输入迭代器一般使用 istream_iterator, 其需要 STL <iterator> 的支持

操作 解释
istream_iterator<typename> in(is) in 从输入流 is (一般为 cin ) 读取 typename 类型的值
istream_iterator<typename> end 读取类型为 typename 的 istream_iterator 迭代器, 表示尾后位置
in1 == in2, in1 != in2 用来检查迭代器是否绑定的是相同的输入. 且 in1 和 in2 的 typename 必须相同.
*in 返回从流中读取的值
in -> mem 与 (*in).mem含义相同
++in, in++ 从输入流读取下一个值

 

下面用一个 accumulate 函数来演示 istream_iterator 的操作

#include <iostream>
#include <iterator>
#include <algorithm>
#include <numeric>

using namespace std;

int main(void)
{
    istream_iterator<int> in(cin);	/*输入1 2 3 4 5 e */
    istream_iterator<int> end;

    cout << *in << endl;
    cout << *(++in) << endl;
    cout << accumulate(in, end, 0) << endl;	/* accumulate 接受一个输入流迭代器和结束输入流迭代器, 最后是起始值*/

    return 0;
}

 

输出结果

1
2
14	/*迭代器发生了移动, 因此为14*/

 

 

 

输出迭代器

 

输出流迭代器一般使用 ostream_iterator. 其需要 STL <iterator> 的支持

操作 解释
ostream_iterator<typename> out(os) out 将类型为 typename 的值写到输入流 os ( 一般为cout )中
ostream_iterator<typename> out(os, d) out 将类型为 typename 的值写到输入流 os 中, 每个输出后面有个字符串 d
out = val 将 val 写入到 out 所绑定 os 中来输出结果, 其中 out 和 val 的类型必须兼容

 

下面用一个 vector 输出的例子来演示 ostream_iterator

#include <iostream>
#include <iterator>
#include <vector>

using namespace std;

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

    for(auto i : V)
        out = i;
    cout << endl;

    return 0;
}

 

输出结果

1 2 3 4 5

 

 

 

前向迭代器

 

顾名思义就是迭代器只能往一个方向移动, 例如 foward_list 使用的迭代器前向迭代器.

 

 

 

双向迭代器

 

顾名思义就是迭代器可以双向移动, 例如 list 使用的迭代器就是双向迭代器. 该迭代器支持单向迭代器操作

 

 

 

随机访问迭代器

 

该迭代器的特点是元素可以使用下标访问, 迭代器之间可以相加相减, 这是单向迭代器和部分双向迭代器 (如 list ) 所做不到的.

常见的有 <vector>, <string>, <deque>, <array> 所用的迭代器

该迭代器支持单向和双向迭代器操作

 

 

 

max()

 

用途 : 求出两者的最大值

一般形式 :

max(val1, val2, cmp);

/* val1 和 val2 为变量或常量, cmp 为二元谓词, 可视情况添加. 返回类型由 val1 和 val2 决定*/

 

#include <iostream>
#include <algorithm>

using namespace std;

int main(void)
{

    cout << max(1, 2) << endl;

    return 0;
}

 

输出结果

2

 

 

 

min()

 

用途 : 求出两者的最小值

一般形式 :

min(val1, val2, cmp);

/* val1 和 val2 为变量或常量, cmp为二元谓词, 可视情况添加. 返回类型由 val1 和 val2 决定*/

 

#include <iostream>
#include <algorithm>

using namespace std;

int main(void)
{

    cout << min(1, 2) << endl;

    return 0;
}

 

输出结果

1

 

 

 

abs()

 

用途 : 求绝对值

一般形式 :

abs(val);

/* val1 为变量或常量, 返回类型由 val 决定*/

 

#include <iostream>
#include <algorithm>

using namespace std;

int main(void)
{
    cout << abs(-1.4) << endl;

    return 0;
}

 

输出结果

1.4

 

 

 

swap()

 

用途 : 交换两个者的值

一般形式 :

swap(x, y);

/* x 和 y 为变量. 返回类型为 void */

 

输出结果

#include <iostream>
#include <algorithm>

using namespace std;

int main(void)
{
    int x = 2;
    int y = 1;

    swap(x, y);

    cout << x << ' ' << y << endl;

    return 0;
}

 

输出结果

1
2

 

 

 

reverse()

 

用途 : 反转容器

一般形式 :

reverse(begin, end);

/* begin 和 end 限定范围. 返回类型为 void . 需要双向迭代器 */

 

#include <iostream>
#include <algorithm>
#include <array>

using namespace std;

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

    reverse(A.begin(), A.end() - 3);

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

    return 0;
}

 

输出结果

7 6 5 4 3 2 1 8 9 10

 

 

 

next_permutation()

 

用途 : 求一次排列

一般形式 :

next_permutation(begin, end, cmp);

/* begin 和 end 限定范围. cmp 为二元谓词, 可视情况添加. 返回类型为 bool. 需要双向迭代器*/

 

#include <iostream>
#include <algorithm>
#include <array>

using namespace std;

int main(void)
{
    array<int, 3> A{1, 2, 3};

    for (int i = 0; i < 6; i++)
    {
        for (auto j : A)
            cout << j << ' ';
        next_permutation(A.begin(), A.end());
        cout << endl;
    }

    return 0;
}

 

输出结果

1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1

 

 

 

fill()

 

用途 : 为容器的某一范围写入新值.

一般形式 :

fill(begin, end, val);

/*  begin 和 end 限定范围. val 为变量或常量. 返回类型为 void */

 

#include <iostream>
#include <algorithm>
#include <array>

using namespace std;

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

    fill(A.begin(), A.end() - 5, 4);

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

    return 0;
}

 

输出结果

4 4 4 4 4 6 7 8 9 10

 

 

 

sort()

 

用途 : 对容器进行升序排序

一般形式 :

sort(begin, end, cmp);

/* begin 和 end 限定范围. cmp 为二元谓词, 可以视情况添加. 返回类型为 void */

 

#include <iostream>
#include <algorithm>
#include <array>

using namespace std;

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

    sort(A.begin(), A.end());

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

    return 0;
}

 

输出结果

1 2 3 4 5 6 7 8 9 10

 

 

 

find()

 

用途 : 查找元素

一般形式 :

find(begin, end, val);

/* begin 和 end 限定范围. val 为要查找的元素. 返回一个指向该元素的迭代器*/

 

#include <iostream>
#include <algorithm>
#include <array>

using namespace std;

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

    auto i = find(A.begin(), A.end(), 4);

    cout << *i << endl;

    return 0;
}

 

输出结果

4

 

 

 

count()

 

用途 : 求出元素在容器中出现的次数.

一般形式 :

count(begin, end, val);

/* begin 和 end 限定范围. val 为要需要求的元素. 返回类型为 ptrdiff_t */

 

#include <iostream>
#include <algorithm>
#include <array>

using namespace std;

int main(void)
{
    array<int, 10> A{10, 10, 10, 4, 5, 5, 2, 1, 1, 0};

    cout << count(A.begin(), A.end(), 10) << endl;
    cout << count(A.begin(), A.end(), 4) << endl;
    cout << count(A.begin(), A.end(), 5) << endl;
    cout << count(A.begin(), A.end(), 2) << endl;
    cout << count(A.begin(), A.end(), 1) << endl;
    cout << count(A.begin(), A.end(), 0) << endl;

    return 0;
}

 

输出结果

3
1
2
1
2
1

 

 

 

accumulate()

 

用途 : 求和. 需要 STL <numeric>, 可以使用输入迭代器.

一般形式 :

accumulate(begin, end, init);

/* begin 和 end 限定范围, 或者是输入迭代器. init 为初始值. 返回类型为 int */

 

#include <iostream>
#include <algorithm>
#include <array>
#include <numeric>
#include <iterator>

using namespace std;

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

    cout << accumulate(A.begin(), A.end(), 0) << endl;

    return 0;
}

 

输出结果

15

 

 

 

lower_bound()

 

用途 : 通过二分法找到第一个小于等于指定元素的元素. 容器最好是有序的

一般形式 :

lower_bound(begin, end, val, cmp);

/*
begin 和 end 限定范围. val 为要查找的元素. cmp为二元谓词, 可视情况添加. 
返回一个小于等于 val 的元素的迭代器
*/

 

#include <iostream>
#include <algorithm>
#include <array>
#include <numeric>

using namespace std;

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

    auto i = lower_bound(A.begin(), A.end(), 4);

    cout << *i << endl;

    return 0;
}

 

输出结果

4

 

 

 

upper_bound()

 

用途 : 通过二分法找到第一个大于指定元素的元素. 容器最好是有序的

一般形式 :

upper_bound(begin, end, val, cmp);

/*
begin 和 end 限定范围. val 为要查找的元素. cmp 为二元谓词, 可视情况添加. 
返回一个大于 val 的元素的迭代器
*/

 

#include <iostream>
#include <algorithm>
#include <array>
#include <numeric>

using namespace std;

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

    auto i = upper_bound(A.begin(), A.end(), 3);

    cout << *i << endl;

    return 0;
}

 

输出结果

4

 

 

 

参考:

 

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

标签：常用,end,迭代,STL,void,begin,C++,int,include
来源： https://www.cnblogs.com/ICeVe/p/14536340.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有