C++ STL模板库08-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_45882170/article/details/140573731

-------------------------------------------------------------------

给一个无单向不循环链表的首结点l，编写程序反转链表，并返回反转后的链表首结点

struct llist_node {
    int val;
    struct llist_node *next;
};

struct llist_node *func(struct llist_node *l)
{
    struct llist_node *cur = l;
    struct llist_node *prev = NULL;    // 指向链表当前节点的上一个节点
    struct llist_node *next = NULL;    // 指向链表当前节点的下一个节点

    while (cur) {
        next = cur->next;
        cur->next = prev;
        prev = cur;
        cur = next;
    }

    return cur;
}

-------------------------------------------------------------------

二、STL模板库----算法（algorithm）

我们所有的算法都是在algorithm头文件中声明，所以在使用前需要包含头文件

#include<algorithm>

1、排序

1）sort()（基于快排实现）

/*
        sort --- 对[first,last)范围内的成员进行排序（默认升序排序）
        first ：一种随机访问迭代器，用于指定要排序范围的起始成员
        last  ：一种随机访问迭代器，用于指定要排序范围的最后一个成员的下一个位置
*/
template <class RandomAccessIterator>  
void sort (RandomAccessIterator first, RandomAccessIterator last);

/*
        sort --- 对[first,last)范围内的成员进行排序（默认升序排序）
        first ：一种随机访问迭代器，用于指定要排序范围的起始成员
        last  ：一种随机访问迭代器，用于指定要排序范围的最后一个成员的下一个位置
        comp  ：调用者自己定义的排序方法
*/
template <class RandomAccessIterator, class Compare>  
void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
/*

ps:

时间复杂度为： $O(N*log2(N))$ ，N为first与last之间的距离

1、容器支持的迭代器类型必须是随机访问迭代器，这意味着，sort()只对array、vector、deque这3个容器提供支持。

2、如果对容器中指定范围的成员做默认升序排序，必须保证该成员类型支持<运算符的运算。

3、sort()函数在实现排序时，需要交换容器中元素的存储位置，这种情况下，如果容器中存储的是自定义的类对象，则该类内部必须提供移动构造函数和移动赋值运算符。

*/

2）stable_sort（基于归并实现）

/*
        stable_sort--- 对[first,last)范围内的成员进行排序（默认升序排序）
        first ：一种随机访问迭代器，用于指定要排序范围的起始成员
        last  ：一种随机访问迭代器，用于指定要排序范围的最后一个成员的下一个位置
*/
template <class RandomAccessIterator>  
void stable_sort(RandomAccessIterator first, RandomAccessIterator last);

/*
        stable_sort--- 对[first,last)范围内的成员进行排序（默认升序排序）
        first ：一种随机访问迭代器，用于指定要排序范围的起始成员
        last  ：一种随机访问迭代器，用于指定要排序范围的最后一个成员的下一个位置
        comp  ：调用者自己定义的排序方法
*/
template <class RandomAccessIterator, class Compare>  
void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp);

ps:

空间足够：时间复杂度为： $O(N*log2(N))$ ，N为first与last之间的距离

空间不足：时间复杂度为： $O(N*log2(N)2)$ ，N为first与last之间的距离

1、同sort()函数

2、可以保证不改变相等元素的相对位置。

3）partial_sort（基于交换元素存储位置实现）

/*
        partial_sort--- 对[first,last)范围内的数据进行筛选并排序（默认升序排序）
        first  ：一种随机访问迭代器，用于指定要排序范围的起始成员
        middle ：一种随机访问迭代器，用于指定要排序的子范围的最后一个成员的下一个位置
        last   ：一种随机访问迭代器，用于指定要排序范围的最后一个成员的下一个位置
*/
template <class RandomAccessIterator>  
void partial_sort (RandomAccessIterator first, 
                   RandomAccessIterator middle,                     
                   RandomAccessIterator last);

/*
        partial_sort--- 对[first,last)范围内的数据进行筛选并排序（默认升序排序）         first  ：一种随机访问迭代器，用于指定要排序范围的起始成员
        middle ：一种随机访问迭代器，用于指定要排序的子范围的最后一个成员的下一个位置         last   ：一种随机访问迭代器，用于指定要排序范围的最后一个成员的下一个位置
        comp   ：调用者自己定义的排序方法
*/
template <class RandomAccessIterator, class Compare> 
void partial_sort (RandomAccessIterator first, 
                   RandomAccessIterator middle, 
                   RandomAccessIterator last, 
                   Compare comp);

ps:

时间复杂度为： $N*log(M)$

其中 N 指的是 [first, last) 范围的长度，M 指的是 [first, middle) 范围的长度。

1、同sort()函数

2、partial_sort() 会将 [first, last) 范围内最小（或最大）的 middle-first 个元素移动到 [first, middle) 区域中，并对这部分元素做升序（或降序）排序。剩余的元素不一定保持原来相对顺序。

2、查找

1）find（基于==运算符）

/*
        find --- 在[first,last)范围内找到和目标元素值相等的第一个元素
        first ：一种输入迭代器，用于指定要排序范围的起始成员
        last  ：一种输入迭代器，用于指定要排序范围的最后一个成员的下一个位置
        val   : 要查找的值
        return ： successed ---  返回一个输入迭代器，指向查找到的第一个元素
                  failed    ---  返回一个输入迭代器，与last指向相同
*/
template <class InputIterator, class T>   
InputIterator find (InputIterator first, InputIterator last, const T& val);

/*底层实现*/

template<class InputIterator, class T>
InputIterator find (InputIterator first, InputIterator last, const T& val)
{
    while (first!=last) {
        if (*first==val) return first;
        ++first;
    }
    return last;
}

ps:

1、使用find()函数时，必须保证查找的元素支持==运算符

2）find_if（基于==运算符）

/*
        find_if --- 在[first,last)范围内找到第一个符合查找规则（返回true）的元素
        first ：一种输入迭代器，用于指定要排序范围的起始成员
        last  ：一种输入迭代器，用于指定要排序范围的最后一个成员的下一个位置
        pred  : 用户自定义的查找规则
        return ： successed ---  返回一个输入迭代器，指向查找到的第一个元素
                  failed    ---  返回一个输入迭代器，与last指向相同
*/
template <class InputIterator, class UnaryPredicate>   
InputIterator find_if (InputIterator first, 
                       InputIterator last, 
                       UnaryPredicate pred);

/*底层实现*/

template<class InputIterator, class UnaryPredicate>
InputIterator find_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
    while (first!=last) {
        if (pred(*first)) return first;
        ++first;
    }
    return last;
}

ps:

1、同find()

3）find_if_not（基于==运算符）

/*
        find_if_not --- 在[first,last)范围内找到第一个不符合查找规则（返回false）的元素
        first ：一种输入迭代器，用于指定要排序范围的起始成员
        last  ：一种输入迭代器，用于指定要排序范围的最后一个成员的下一个位置
        pred  : 用户自定义的查找规则
        return ： successed ---  返回一个输入迭代器，指向查找到的第一个元素
                  failed    ---  返回一个输入迭代器，与last指向相同
*/
template <class InputIterator, class UnaryPredicate>   
InputIterator find_if_not(InputIterator first, 
                       InputIterator last, 
                       UnaryPredicate pred);

/*底层实现*/

template<class InputIterator, class UnaryPredicate>
InputIterator find_if_not (InputIterator first, InputIterator last, UnaryPredicate pred)
{
    while (first!=last) {
        if (!pred(*first)) return first;
        ++first;
    }
    return last;
}

ps:

1、同find()

4）find_end（基于==运算符）

/*
        find_if_not --- 查找序列 [first1, last1) 中最后一个子序列 [first2, last2)
        first1 ：一种向前迭代器，用于指定要查找范围的起始成员
        last1  ：一种向前迭代器，用于指定要查找范围的最后一个成员的下一个位置
        first2 ：一种向前迭代器，用于指定要查找序列的起始成员         
        last2  ：一种向前迭代器，用于指定要查找序列的最后一个成员的下一个位置
        return ： successed ---  返回一个输入迭代器，指向查找到的子序列中的第一个元素
                  failed    ---  返回一个输入迭代器，与last1指向相同
*/
template <class ForwardIterator1, class ForwardIterator2>   
ForwardIterator1 find_end (ForwardIterator1 first1, 
                           ForwardIterator1 last1,
                           ForwardIterator2 first2, 
                           ForwardIterator2 last2);

/*      find_if_not --- 查找序列 [first1, last1) 与序列 [first2, last2)满足pred规则的最后一个子序列
        first1 ：一种向前迭代器，用于指定要查找范围的起始成员         
        last1  ：一种向前迭代器，用于指定要查找范围的最后一个成员的下一个位置
        first2 ：一种向前迭代器，用于指定要查找序列的起始成员         
        last2  ：一种向前迭代器，用于指定要查找序列的最后一个成员的下一个位置
        pred   ：用户自定义的查找规则        
        return ： successed --- 返回一个输入迭代器，指向查找到的子序列中的第一个元素                   failed    --- 返回一个输入迭代器，与last1指向相同 
*/
template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>   ForwardIterator1 find_end (ForwardIterator1 first1, 
                           ForwardIterator1 last1,                                                         ForwardIterator2 first2, 
                           ForwardIterator2 last2,                                                         BinaryPredicate pred);

/*底层实现*/

template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1,
  ForwardIterator2 first2, ForwardIterator2 last2)
{
    if (first2 == last2) return last1;  // specified in C++11
    ForwardIterator1 ret = last1;
    while (first1 != last1)
    {
        ForwardIterator1 it1 = first1;
        ForwardIterator2 it2 = first2;
        while (*it1 == *it2) {    // or: while (pred(*it1,*it2)) for version (2)
            ++it1; ++it2;
            if (it2 == last2) { ret = first1; break; }
            if (it1 == last1) return ret;
        }
        ++first1;
    }
    return ret;
}

ps:

1、同find()

2、第一种语法格式也可以看做是包含一个默认的 pred 参数，该参数指定的是一种相等规则，即在 [first1, last1) 范围内查找和 [first2, last2) 中各个元素对应相等的子序列；而借助第二种语法格式，我们可以自定义一个当前场景需要的匹配规则。

3、遍历

1）for_each()

/*
        for_each --- 将函数fn应用在[first, last) 中的每一个元素
        first ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last  ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        fn    ：用户自定义的函数
*/
template <class InputIterator, class Function>   
Function for_each (InputIterator first, InputIterator last, Function fn);

/*底层实现*/

template<class InputIterator, class Function>
  Function for_each(InputIterator first, InputIterator last, Function fn)
{
  while (first!=last) {
    fn (*first);
    ++first;
  }
  return fn;      // or, since C++11: return move(fn);
}

ps:

1、传参时，除了定义全局函数或定义仿函数类之外，我们还可以使用匿名函数

--------------------------------------------------------------------

匿名函数：(没有名字的函数)

ISO C++ 11标准中引入了匿名函数的内容

匿名函数也叫做Lambda函数或者Lambda表达式，用希腊字母λ表示

Lambda表达式本质上和函数声明相似

[捕获列表](参数列表) mutable noexcept/throw() -> 返回类型 {
// 函数体实现
}

ps:在使用了捕获列表的情况下，再进行编译时要加 -std=c++11 选项

匿名函数各部分含义说明
[捕获列表]	方括号用于向编译器表明当前是一个 lambda 表达式，其不能被省略。在方括号内部，可以注明当前 lambda 函数的函数体中可以使用哪些“外部变量”。所谓外部变量，指的是和当前 lambda 表达式位于同一作用域内的所有局部变量。
(参数列表)	和普通函数的定义一样，lambda 匿名函数也可以接收外部传递的多个参数。和普通函数不同的是，如果不需要传递参数，可以连同 () 小括号一起省略；
mutable	默认情况下，对于以值传递引入的外部变量，不允许在 lambda 表达式内部修改它们的值。可以理解为这部分变量都是 const 常量。如果想修改它们，就必须使用 mutable 关键字，此时小括号()不可省略。 ps:对于以值传递方式引入的外部变量，lambda 表达式修改的是拷贝的那一份，并不会修改真正的外部变量；
noexcept/throw()	默认情况下，lambda 函数的函数体中可以抛出任何类型的异常。而标注 noexcept 关键字，则表示函数体内不会抛出任何异常；使用 throw() 可以指定 lambda 函数内部可以抛出的异常类型。若使用该关键字，则小括号()不可省略。 ps:如果 lambda 函数标有 noexcept 而函数体内抛出了异常，又或者使用 throw() 限定了异常类型而函数体内抛出了非指定类型的异常，这些异常无法使用 try-catch 捕获，会导致程序执行失败；
-> 返回类型	指明 lambda 匿名函数的返回值类型。 ps:如果 lambda 函数体内只有一个 return 语句，或者该函数返回 void，则编译器可以自行推断出返回值类型，此情况下可以直接省略；
// 函数体实现	和普通函数一样，lambda 匿名函数包含的内部代码都放置在函数体中。该函数体内除了可以使用指定传递进来的参数之外，还可以使用指定的外部变量以及全局范围内的所有全局变量。 ps:外部变量会受到以值传递还是以引用传递方式引入的影响，而全局变量则不会。换句话说，在 lambda 表达式内可以使用任意一个全局变量，必要时还可以直接修改它们的值。

[捕获列表]的定义方式
[]	空方括号表示当前 lambda 匿名函数中不捕获任何外部变量。
[=]	只有一个 = 等号，表示以值传递的方式捕获所有外部变量；
[&]	只有一个 & 符号，表示以引用传递的方式捕获所有外部变量；
[val1,val2,...]	表示以值传递的方式捕获 val1、val2 等指定的外部变量，同时多个变量之间没有先后次序；
[&val1,&val2,...]	表示以引用传递的方式捕获 val1、val2等指定的外部变量，多个变量之间没有前后次序；
[&,val2,...]	表示除 val2 以值传递的方式捕获外，其它外部变量都以引用传递的方式捕获。
[=,&val1,...]	表示除 val1 以引用传递的方式捕获外，其它外部变量都以值传递的方式捕获。
[this]	表示以引用的方式捕获当前的对象。（值传递方式捕获指针）
*[this]**	表示以值传递的方式捕获当前的对象。
ps:单个外部变量不允许以相同的传递方式导入多次。

--------------------------------------------------------------------

2）all_of

/*
        all_of --- 检查容器中指定范围[first, last)的元素是否都满足给定的条件
        first  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last   ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        pred   ：用户自定义的条件
        return ： successed --- 返回true
                  failed    --- 返回false        
*/
template <class InputIterator, class UnaryPredicate>  
bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred);

/*底层实现*/

template<class InputIterator, class UnaryPredicate>
  bool all_of (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (!pred(*first)) return false;
    ++first;
  }
  return true;
}

ps:

1、传参时，除了定义全局函数或定义仿函数类之外，我们还可以使用匿名函数

3）any_of

/*
        any_of --- 检查容器中指定范围[first, last)是否存在满足给定条件的元素
        first  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last   ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        pred   ：用户自定义的条件
        return ： successed --- 返回true
                  failed    --- 返回false        
*/
template <class InputIterator, class UnaryPredicate>  
bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred);

/*底层实现*/

template<class InputIterator, class UnaryPredicate>
  bool any_of (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (pred(*first)) return true;
    ++first;
  }
  return false;
}

ps:

1、传参时，除了定义全局函数或定义仿函数类之外，我们还可以使用匿名函数

4）none_of

/*
        none_of --- 检查容器中指定范围[first, last)的元素是否都不满足给定的条件
        first  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last   ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        pred   ：用户自定义的条件
        return ： successed --- 返回true
                  failed    --- 返回false        
*/
template <class InputIterator, class UnaryPredicate>  
bool none_of (InputIterator first, InputIterator last, UnaryPredicate pred);

/*底层实现*/

template<class InputIterator, class UnaryPredicate>
  bool none_of (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  while (first!=last) {
    if (pred(*first)) return false;
    ++first;
  }
  return true;
}

ps:

1、传参时，除了定义全局函数或定义仿函数类之外，我们还可以使用匿名函数

5）count

/*
        count  --- 累计指定范围[first, last)中元素的值与给定值val相同的个数
        first  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last   ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        val    ：用户指定的值       
*/
template <class InputIterator, class T>  typename iterator_traits<InputIterator>::difference_type count (InputIterator first,
                                                       InputIterator last, 
                                                       const T& val);

/*底层实现*/

template <class InputIterator, class T>
  typename iterator_traits<InputIterator>::difference_type
    count (InputIterator first, InputIterator last, const T& val)
{
  typename iterator_traits<InputIterator>::difference_type ret = 0;
  while (first!=last) {
    if (*first == val) ++ret;
    ++first;
  }
  return ret;
}

6）count_if

/*
        count_if --- 累计指定范围[first, last)中满足pred条件的元素个数
        first  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last   ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        pred   ：用户自定义的条件       
*/
template <class InputIterator, class UnaryPredicate>  typename iterator_traits<InputIterator>::difference_type count_if (InputIterator first,
                                                          InputIterator last, 
                                                          UnaryPredicate pred);

/*底层实现*/

template <class InputIterator, class UnaryPredicate>
  typename iterator_traits<InputIterator>::difference_type
    count_if (InputIterator first, InputIterator last, UnaryPredicate pred)
{
  typename iterator_traits<InputIterator>::difference_type ret = 0;
  while (first!=last) {
    if (pred(*first)) ++ret;
    ++first;
  }
  return ret;
}

4、比较

1）mismatch（基于==运算符）

 /*
        mismatch --- 对比序列一[first1,last1)与序列二[first2,。。。)是否匹配
        first1  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last1   ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        first2  ：一种输入迭代器，用于指向与第一个序列进行匹配的元素首地址
        return  ： InputIterator1--- 指向[first1,last1)中第一个不匹配的元素位置
                   InputIterator2--- 指向[first2,。。。)中第一个不匹配元素的位置
*/
template <class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2>    mismatch (InputIterator1 first1,
                                                  InputIterator1 last1,
                                                  InputIterator2 first2);

 /*     
        mismatch --- 按照pred方法，对比序列一[first1,last1)与序列二[first2,。。。)是否匹配
        first1 ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last1  ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置             first2 ：一种输入迭代器，用于指向与第一个序列进行匹配的元素首地址
        pred   ：用户自定义匹配方法
        return ： InputIterator1--- 指向[first1,last1)中第一个不匹配的元素位置
                  InputIterator2--- 指向[first2,。。。)中第一个不匹配元素的位置
*/
template <class InputIterator1, class InputIterator2, class BinaryPredicate> pair<InputIterator1, InputIterator2> mismatch (InputIterator1 first1,
                                                 InputIterator1 last1,
                                                 InputIterator2 first2,
                                                 BinaryPredicate pred);

/*底层实现*/

template <class InputIterator1, class InputIterator2>
  pair<InputIterator1, InputIterator2>
    mismatch (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
  while ( (first1!=last1) && (*first1==*first2) )  // or: pred(*first1,*first2), for version 2
  { ++first1; ++first2; }
  return std::make_pair(first1,first2);
}

ps:

1、传参时，除了定义全局函数或定义仿函数类之外，我们还可以使用匿名函数

2、使用mismatch()函数时，必须保证查找的元素支持==运算符

2）equal（基于==运算符）

 /*
        equal --- 对比序列一[first1,last1)与序列二[first2,。。。)是否匹配
        first1  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last1   ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        first2  ：一种输入迭代器，用于指向与第一个序列进行匹配的元素首地址
        return ： successed --- 返回true                  
                  failed    --- 返回false  
*/
template <class InputIterator1, class InputIterator2>
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);

 /*     
        equal --- 按照pred方法，对比序列一[first1,last1)与序列二[first2,。。。)是否匹配
        first1 ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last1  ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置             first2 ：一种输入迭代器，用于指向与第一个序列进行匹配的元素首地址
        pred   ：用户自定义匹配方法
        return ： successed --- 返回true                 
                  failed    --- 返回false
*/
template <class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2,             BinaryPredicate pred);

/*底层实现*/

template <class InputIterator1, class InputIterator2>
  bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
  while (first1!=last1) {
    if (!(*first1 == *first2))   // or: if (!pred(*first1,*first2)), for version 2
      return false;
    ++first1; ++first2;
  }
  return true;
}

ps:

1、传参时，除了定义全局函数或定义仿函数类之外，我们还可以使用匿名函数

2、使用equal()函数时，必须保证查找的元素支持==运算符

5、复制

1）copy

 /*
        copy --- 将容器范围为[first, last)的内容拷贝到以result为起始的位置
        first  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        last   ：一种输入迭代器，用于指向要操作的范围中的最后一个元素的下一个位置    
        result ：一种输出迭代器，用于指向要拷贝的位置 
*/
template <class InputIterator, class OutputIterator>
OutputIterator copy (InputIterator first,
                     InputIterator last,
                     OutputIterator result);

/*底层实现*/

template<class InputIterator, class OutputIterator>
  OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result)
{
  while (first!=last) {
    *result = *first;
    ++result; ++first;
  }
  return result;
}

ps:

1、copy()函数只负责拷贝内容，不负责申请空间，需要在拷贝前保证空间足够

2）copy_n

 /*
        copy_n --- 将容器以first为起始位置的n个元素拷贝到以result为起始的位置
        first  ：一种输入迭代器，用于指向要操作的范围中的第一个元素的位置
        n      ：用户指定要拷贝的元素个数    
        result ：一种输出迭代器，用于指向要拷贝的位置 
*/
template <class InputIterator, class Size, class OutputIterator>
OutputIterator copy_n (InputIterator first, Size n, OutputIterator result);

/*底层实现*/

template<class InputIterator, class Size, class OutputIterator>
  OutputIterator copy_n (InputIterator first, Size n, OutputIterator result)
{
  while (n>0) {
    *result = *first;
    ++result; ++first;
    --n;
  }
  return result;
}

ps:

1、同copy()

2、如果n的值超过了实际元素的值，程序会崩溃

3、如果n的值为0或负数，该方法什么也不会执行

3）copy_backward

 /*
     copy_backward --- 将容器范围为[first, last)的内容拷贝到以result为起始的位置
     first  ：一种双向迭代器，用于指向要操作的范围中的第一个元素的位置
     last   ：一种双向迭代器，用于指向要操作的范围中的最后一个元素的下一个位置  
     result ：一种双向迭代器，用于指向要拷贝的位置（从后向前复制，元素间相对顺序不变） 
*/
template <class BidirectionalIterator1, class BidirectionalIterator2>  BidirectionalIterator2 copy_backward (BidirectionalIterator1 first,
                                      BidirectionalIterator1 last,
                                      BidirectionalIterator2 result);

/*底层实现*/

template<class BidirectionalIterator1, class BidirectionalIterator2>
  BidirectionalIterator2 copy_backward ( BidirectionalIterator1 first,
                                         BidirectionalIterator1 last,
                                         BidirectionalIterator2 result )
{
  while (last!=first) *(--result) = *(--last);
  return result;
}

ps:

1、同copy()

2、使用copy()函数，可以将要拷贝的元素拷贝到目的容器的左边

3、使用copy_backward()函数，可以将要拷贝的元素拷贝到目的容器的右边

4、它从最后一个元素开始直到第一个元素，但元素间的相对顺序保持不变

6、移动

1）move

 /*
     move --- 将容器范围为[first, last)的元素强制转化为右值，依次赋值给以result为起始位置的元素
     first  ：一种双向迭代器，用于指向要操作的范围中的第一个元素的位置
     last   ：一种双向迭代器，用于指向要操作的范围中的最后一个元素的下一个位置  
     result ：一种双向迭代器，用于指向要拷贝的位置 
*/
template <class InputIterator, class OutputIterator>
OutputIterator move (InputIterator first, InputIterator last,
                     OutputIterator result);
/*底层实现*/
template<class InputIterator, class OutputIterator>
  OutputIterator move (InputIterator first, InputIterator last, OutputIterator result)
{
  while (first!=last) {
    *result = std::move(*first);
    ++result; ++first;
  }
  return result;
}
/*

ps:

1、move()函数并没有做任何的移动操作

2、move()函数可以强制将左值转换为右值，让右值引用可以指向左值

3、右值引用和std::move被广泛用于在STL和自定义类中实现移动语义，避免拷贝，从而提升程序性能。

4、可移动对象在<需要拷贝且被拷贝者之后不再被需要>的场景，建议使用std::move触发移动语义，提升性能

*/

2）move_backward

 /*
     move_backward --- 将容器范围为[first, last)的元素强制转化为右值，依次赋值给以result为起始位置的元素
     first  ：一种双向迭代器，用于指向要操作的范围中的第一个元素的位置
     last   ：一种双向迭代器，用于指向要操作的范围中的最后一个元素的下一个位置  
     result ：一种双向迭代器，用于指向要拷贝的位置（从后向前移动，元素间相对顺序不变） 
*/
template <class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2 move_backward (BidirectionalIterator1 first,
                                      BidirectionalIterator1 last,
                                      BidirectionalIterator2 result);

/*底层实现*/

template<class BidirectionalIterator1, class BidirectionalIterator2>
  BidirectionalIterator2 move_backward ( BidirectionalIterator1 first,
                                         BidirectionalIterator1 last,
                                         BidirectionalIterator2 result )
{
  while (last!=first) *(--result) = std::move(*(--last));
  return result;
}

ps:

1、同move()

2、与move()不同的是，move_backward()用于将对象按逆序移动。它可以将一系列对象从一个范围移动到另一个范围，保持原始顺序不变。这在需要从尾部开始移动对象的情况下非常有用。

7、交换

1）swap

 /*
     swap --- 交换对象a与对象b
     a  ：模板类型
     b  ：模板类型
*/
template <class T> void swap (T& a, T& b);

/*底层实现*/

template <class T> void swap ( T& a, T& b )
{
  T c(a); a=b; b=c;
}

2）swap_range

 /*
     swap_ranges --- 将序列一[first, last)与序列二[first2,。。。)进行交换
     first1  ：一种正向迭代器，用于指向要操作的范围中的第一个元素的位置
     last1   ：一种正向迭代器，用于指向要操作的范围中的最后一个元素的下一个位置        first2  ：一种正向迭代器，用于指向要交换的位置
*/
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,
                              ForwardIterator2 first2);

/*底层实现*/

template<class ForwardIterator1, class ForwardIterator2>
  ForwardIterator2 swap_ranges (ForwardIterator1 first1, ForwardIterator1 last1,
                                ForwardIterator2 first2)
{
  while (first1!=last1) {
    swap (*first1, *first2);
    ++first1; ++first2;
  }
  return first2;
}

ps:

1、交换的两个序列，其长度必须相同