《C++ primer plus》附录G：STL方法与函数（三） 学习笔记

27个修改修改序列的操作

1.copy()

从序列的第一个元素起进行复制

template< class InputIt, class OutputIt >OutputIt copy( InputIt first, InputIt last, OutputIt d_first );

2.copy_backward()

从序列的最后一个元素起进行复制

template< class BidirIt1, class BidirIt2 >BidirIt2 copy_backward( BidirIt1 first, BidirIt1 last, BidirIt2 d_last );

3.swap()

交换引用指定位置的两个元素

template< class T >void swap( T& a, T& b );

4.swap_ranges()

交换两个区间对应的元素进行交换

template< class ForwardIt1, class ForwardIt2 >ForwardIt2 swap_ranges( ForwardIt1 first1, ForwardIt1 last1, ForwardIt2 first2 );

5.iter_swap()

交换由迭代器所指的两个元素

template< class ForwardIt1, class ForwardIt2 >void iter_swap( ForwardIt1 a, ForwardIt2 b );

6.transform()

将某操作应用于指定范围的每个元素，第一个版本将一元函数对象应用于每一个元素，并将结果返回给result开始的区间对应的元素
第二个版本将二元函数应用于[first1,last1),[first2,last2)的每一个元素，并将结果返回给result开始的区间对应的元素

template< class InputIt, class OutputIt, class UnaryOperation >OutputIt transform( InputIt first1, InputIt last1, OutputIt d_first,UnaryOperation unary_op );template< class InputIt1, class InputIt2, class OutputIt, class BinaryOperation >OutputIt transform( InputIt1 first1, InputIt1 last1, InputIt2 first2, OutputIt d_first, BinaryOperation binary_op );

7.replace()

将[first,last)中的所有的old_value元素转化为new_value

template< class ForwardIt, class T >void replace( ForwardIt first, ForwardIt last,const T& old_value, const T& new_value );

8.replace_if()

将[first,last)中的所有使pre(old)为true的元素转化为new_value

template< class ForwardIt, class UnaryPredicate, class T >void replace_if( ForwardIt first, ForwardIt last,UnaryPredicate p, const T& new_value );

9.replace_copy()

将[first,last)中的元素复制到result开始的区间中，不过该函数用new_value替换所有的old_value，返回目标区间的超尾值

template< class InputIt, class OutputIt, class T >OutputIt replace_copy( InputIt first, InputIt last, OutputIt d_first,const T& old_value, const T& new_value );

10.replace_copy_if()

template< class InputIt, class OutputIt, class UnaryPredicate, class T >OutputIt replace_copy_if( InputIt first, InputIt last, OutputIt d_first,UnaryPredicate p, const T& new_value );

11.fill()

将[first,last)中的所有元素设置为value

template< class ForwardIt, class T >void fill( ForwardIt first, ForwardIt last, const T& value );

12.fill_n()

将从first开始的n个元素设置为value

template< class OutputIt, class Size, class T >OutputIt fill_n( OutputIt first, Size count, const T& value );

13.generate()

将[first,last)区间的元素设置为gen()，其中gen为一个生成器函数对象，不接受任何参数，如rand()

template< class ForwardIt, class Generator >void generate( ForwardIt first, ForwardIt last, Generator g );

#include <algorithm>#include <iostream>#include <vector>#include <cstdlib> int main(){    std::vector<int> v(5);    std::generate(v.begin(), v.end(), std::rand); // Using the C function rand()     std::cout << "v: ";    for (auto iv: v) {        std::cout << iv << " ";    }    std::cout << "\n";     // Initialize with default values 0,1,2,3,4 from a lambda function    // Equivalent to std::iota(v.begin(), v.end(), 0);    int n = {0};    std::generate(v.begin(), v.end(), [&n]{ return n++; });     std::cout << "v: ";    for (auto iv: v) {        std::cout << iv << " ";    }    std::cout << "\n";}/*输出结果为：v: 52894 15984720 41513563 41346135 51451456v: 0 1 2 3 4 */

14.generate_n()

将[first,last)中的所有元素设置为gen()

template< class ForwardIt, class Size, class Generator >ForwardIt generate_n( ForwardIt first, Size count, Generator g );

15.remove()

删除[first,last)中所有值为value的元素，并返回所得区间的超尾迭代器，该函数是稳定的，意味着未删除的元素的顺序保持不变

void remove( const T& value );

16.remove_if()

template< class UnaryPredicate >void remove_if( UnaryPredicate p );

17.remove_copy()

将[first,last)中的值复制到result的区间中，复制时将忽略value

template< class InputIt, class OutputIt, class T >OutputIt remove_copy( InputIt first, InputIt last, OutputIt d_first,const T& value );

#include <algorithm>#include <iterator>#include <string>#include <iostream>int main(){    std::string str = "Text with some   spaces";    std::cout << "before: " << str << "\n";     std::cout << "after:  ";    std::remove_copy(str.begin(), str.end(),                     std::ostream_iterator<char>(std::cout), ' ');    std::cout << '\n';}/*输出结果为：before: Text with some   spacesafter:  Textwithsomespaces */

18.remove_copy_if()

template< class InputIt, class OutputIt, class UnaryPredicate >OutputIt remove_copy_if( InputIt first, InputIt last, OutputIt d_first,UnaryPredicate p );

19.unique()

删除相邻的重复元素，第一个版本用==对元素进行比较，第二个版本使用二元断言函数对象

template< class ForwardIt >ForwardIt unique( ForwardIt first, ForwardIt last );template< class ForwardIt, class BinaryPredicate >ForwardIt unique( ForwardIt first, ForwardIt last, BinaryPredicate p );

20.unique_copy()

复制序列是删除相同的元素

template< class InputIt, class OutputIt >OutputIt unique_copy( InputIt first, InputIt last,OutputIt d_first );template< class InputIt, class OutputIt, class BinaryPredicate >OutputIt unique_copy( InputIt first, InputIt last,OutputIt d_first, BinaryPredicate p );

21.reverse()

反转区间中的元素

template< class BidirIt >void reverse( BidirIt first, BidirIt last );

22.reverse_copy()

复制序列时反转元素的次序

template< class BidirIt, class OutputIt >OutputIt reverse_copy( BidirIt first, BidirIt last, OutputIt d_first );

23.rotate()

rotate()将[first,last)中的元素左旋，middle中的元素被移动到了first出，middle+1处的元素被移动到了first+1处，middle前的元素绕回容器尾部，以便first处的元素可以紧接着last-1出的元素

template< class ForwardIt >ForwardIt rotate( ForwardIt first, ForwardIt middle, ForwardIt last );

#include <vector>#include <iostream>#include <algorithm> int main(){    std::vector<int> v{2, 4, 2, 0, 5, 10, 7, 3, 7, 1};      std::cout << "before sort:      ";    for (int n: v)        std::cout << n << ' ';    std::cout << '\n';     // insertion sort    for (auto i = v.begin(); i != v.end(); ++i) {        std::rotate(std::upper_bound(v.begin(), i, *i), i, i+1);    }     std::cout << "after sort:       ";    for (int n: v)        std::cout << n << ' ';    std::cout << '\n';     // simple rotation to the left    std::rotate(v.begin(), v.begin() + 1, v.end());     std::cout << "simple rotate left  : ";    for (int n: v)        std::cout << n << ' ';    std::cout << '\n';     // simple rotation to the right    std::rotate(v.rbegin(), v.rbegin() + 1, v.rend());     std::cout << "simple rotate right : ";    for (int n: v)        std::cout << n << ' ';    std::cout << '\n'; }/*输出结果为：before sort:      2 4 2 0 5 10 7 3 7 1 after sort:       0 1 2 2 3 4 5 7 7 10 simple rotate left : 1 2 2 3 4 5 7 7 10 0simple rotate right: 0 1 2 2 3 4 5 7 7 10 */

24.rotate_copy()

复制序列时左旋元素

template< class ForwardIt, class OutputIt >OutputIt rotate_copy( ForwardIt first, ForwardIt n_first,ForwardIt last, OutputIt d_first );

#include <algorithm>#include <vector>#include <iostream> int main(){    std::vector<int> src = {1, 2, 3, 4, 5};     auto pivot = std::find(src.begin(), src.end(), 3);     std::vector<int> dest(src.size());                                               std::rotate_copy(src.begin(), pivot, src.end(), dest.begin());     for (const auto &i : dest) {        std::cout << i << ' ';    }       std::cout << '\n';}/*输出结果为：3 4 5 1 2 */

25.random_shuffle()

第一个版本将[first,last)区间的元素打乱，分布是一致的，即原始顺序的每种可能的排列顺序出现的可能性相同
第二个版本有函数对象确定分布

template< class RandomIt >void random_shuffle( RandomIt first, RandomIt last );template< class RandomIt, class RandomFunc >void random_shuffle( RandomIt first, RandomIt last, RandomFunc&& r );

#include <random>#include <algorithm>#include <iterator>#include <iostream> int main(){    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};     std::random_device rd;    std::mt19937 g(rd());     std::shuffle(v.begin(), v.end(), g);     std::copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));    std::cout << "\n";}/*输出结果为：8 6 10 4 2 3 7 1 9 5 */

26. partition()

将满足pred(val)为true的元素放在不满足该条件的元素的前面，最后返回一个迭代器，该迭代器指向最后一个使得断言函数为true的值的后面

template< class ForwardIt, class UnaryPredicate >ForwardIt partition( ForwardIt first, ForwardIt last, UnaryPredicate p );

#include <algorithm>#include <iostream>#include <iterator>#include <vector>#include <forward_list> template <class ForwardIt> void quicksort(ForwardIt first, ForwardIt last) {    if(first == last) return;    auto pivot = *std::next(first, std::distance(first,last)/2);    ForwardIt middle1 = std::partition(first, last,                          [pivot](const auto& em){ return em < pivot; });    ForwardIt middle2 = std::partition(middle1, last,                          [pivot](const auto& em){ return !(pivot < em); });    quicksort(first, middle1);    quicksort(middle2, last); } int main(){    std::vector<int> v = {0,1,2,3,4,5,6,7,8,9};    std::cout << "Original vector:\n    ";    for (int elem : v) std::cout << elem << ' ';     auto it = std::partition(v.begin(), v.end(), [](int i){return i % 2 == 0;});     std::cout << "\nPartitioned vector:\n    ";    std::copy(std::begin(v), it, std::ostream_iterator<int>(std::cout, " "));    std::cout << " * ";    std::copy(it, std::end(v), std::ostream_iterator<int>(std::cout, " "));     std::forward_list<int> fl = {1, 30, -4, 3, 5, -4, 1, 6, -8, 2, -5, 64, 1, 92};    std::cout << "\nUnsorted list:\n    ";    for(int n : fl) std::cout << n << ' ';    std::cout << '\n';       quicksort(std::begin(fl), std::end(fl));    std::cout << "Sorted using quicksort:\n    ";    for(int fi : fl) std::cout << fi << ' ';    std::cout << '\n';}/*输出结果为：Original vector:    0 1 2 3 4 5 6 7 8 9 Partitioned vector:    0 8 2 6 4  *  5 3 7 1 9 Unsorted list:    1 30 -4 3 5 -4 1 6 -8 2 -5 64 1 92 Sorted using quicksort:    -8 -5 -4 -4 1 1 1 2 3 5 6 30 64 92 */

27.stable_partition()

与partition()的区别在于，该函数使得除了将满足pred(val)为true的元素放在不满足该条件的元素的前面，其他元素的相对位置不变

template< class BidirIt, class UnaryPredicate >BidirIt stable_partition( BidirIt first, BidirIt last, UnaryPredicate p );