（P79）stl(七)：变动性算法

1.变动性算法

• 变动性算法
  for_each
  copy，从头到尾拷贝
  copy_backward，从后往前拷贝
  transform，进行某种变换
  replace
  replace_copy，replace_copy在拷贝的过程中，执行某动作，原区间不改，目标区间会更改
  replace_copy_if，

• eg：P79\01.cpp

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void print_element(int n)
{
    cout <<n<<' ';
}

void add_3(int& n)
{
    n += 3;
}

int main(void)
{
    //容器在构造的时候可以不传递参数，也可以传递2个参数，容器中的区间都是是一个闭开区间[)
    //所有STL区间都是闭开区间
    //end应该指向5后面的位置，那么begin就指向1
    //a，a+5迭代器，这俩迭代器实现的方式是类，其内部持有了int*，所以本质上类型是int*
    int a[] = {1, 2, 3, 4, 5};
    vector<int> v(a, a+5);

    //使用算法
    for_each(v.begin(), v.end(), print_element);
    cout<<endl;

    //for_each是变动性还是非变动性算法，取决于第3个参数：是否更改容器中的元素
    for_each(v.begin(), v.end(), add_3);

    for_each(v.begin(), v.end(), print_element);
    cout<<endl;

    return 0;

}

• 测试
  

• 断点：

    for_each(v.begin(), v.end(), add_3);

判断区间是否合法；
判断指针是否合法；
定义迭代器变量；

注意*运算符返回的是引用，引用指向容器中的某个元素，对引用进行更改能够影响到容器中的元素

• eg：P79\02.cpp

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

void print_element(int n)
{
    cout <<n<<' ';
}

void add_3(int& n)
{
    n += 3;
}

int main(void)
{
    //容器在构造的时候可以不传递参数，也可以传递2个参数，容器中的区间都是是一个闭开区间[)
    //所有STL区间都是闭开区间
    //end应该指向5后面的位置，那么begin就指向1
    //a，a+5迭代器，这俩迭代器实现的方式是类，其内部持有了int*，所以本质上类型是int*
    int a[] = {1, 2, 3, 4, 5};
    vector<int> v(a, a+5);
    list<int> l(5);//list<int> l;错误，copy要求目标的空间已经存在

    //使用算法
    for_each(v.begin(), v.end(), print_element);
    cout<<endl;

    //for_each是变动性还是非变动性算法，取决于第3个参数：是否更改容器中的元素
    for_each(v.begin(), v.end(), add_3);

    for_each(v.begin(), v.end(), print_element);
    cout<<endl;

    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    //copy要求目标的空间已经存在
    copy(v.begin(),v.end(), l.begin());
    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    return 0;

}

• 测试：
  

• 断点：

    copy(v.begin(),v.end(), l.begin());

• eg：P79\03.cpp

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

void print_element(int n)
{
    cout <<n<<' ';
}

void add_3(int& n)
{
    n += 3;
}

int main(void)
{
    //容器在构造的时候可以不传递参数，也可以传递2个参数，容器中的区间都是是一个闭开区间[)
    //所有STL区间都是闭开区间
    //end应该指向5后面的位置，那么begin就指向1
    //a，a+5迭代器，这俩迭代器实现的方式是类，其内部持有了int*，所以本质上类型是int*
    int a[] = {1, 2, 3, 4, 5};
    vector<int> v(a, a+5);
    list<int> l(10);//list<int> l;错误，copy要求目标的空间已经存在

    //使用算法
    for_each(v.begin(), v.end(), print_element);
    cout<<endl;

    //for_each是变动性还是非变动性算法，取决于第3个参数：是否更改容器中的元素
    for_each(v.begin(), v.end(), add_3);

    for_each(v.begin(), v.end(), print_element);
    cout<<endl;

    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    //copy要求目标的空间已经存在
    copy(v.begin(),v.end(), l.begin());
    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    copy_backward(v.begin(),v.end(), l.end());
    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    return 0;

}

• 测试：
  

• 断点：

    copy_backward(v.begin(),v.end(), l.end());

• eg：P79\04.cpp

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

void print_element(int n)
{
    cout <<n<<' ';
}

void add_3(int& n)
{
    n += 3;
}

int fun(int n)
{
    return 2 * a;
}

int main(void)
{
    //容器在构造的时候可以不传递参数，也可以传递2个参数，容器中的区间都是是一个闭开区间[)
    //所有STL区间都是闭开区间
    //end应该指向5后面的位置，那么begin就指向1
    //a，a+5迭代器，这俩迭代器实现的方式是类，其内部持有了int*，所以本质上类型是int*
    int a[] = {1, 2, 3, 4, 5};
    vector<int> v(a, a+5);
    list<int> l(5);

    //原区间不变，目标区间会变
    transform(v.begin(), v.end(), l.begin(), fun);
    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    return 0;

}

4个参数的：
transform()不会用的话，vs键入F1帮助即可
从_First遍历到_Last，执行一个函数_Func，然后把它变换到目标区间中
_Func是一个一元函数，就是只接受一个参数
5个参数的：
两个区间进行某种运算，然后插入到_Result
_Func是一个二元函数

• 测试：
  
• 断点：

transform(v.begin(), v.end(), l.begin(), fun);

原区间不变，目标区间会变

• eg：P79\05.cpp

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

void print_element(int n)
{
    cout << n << ' ';
}

void add_3(int& n)
{
    n += 3;
}

int fun(int n)
{
    return 2 * n;
}

int fun2(int a, int b)
{
    return a + b;
}

int main(void)
{
    //容器在构造的时候可以不传递参数，也可以传递2个参数，容器中的区间都是是一个闭开区间[)
    //所有STL区间都是闭开区间
    //end应该指向5后面的位置，那么begin就指向1
    //a，a+5迭代器，这俩迭代器实现的方式是类，其内部持有了int*，所以本质上类型是int*
    int a[] = { 1, 2, 3, 4, 5 };
    vector<int> v(a, a + 5);
    list<int> l(5);
    list<int> l2(2);

    //原区间不变，目标区间会变
    transform(v.begin(), v.end(), l.begin(), fun);
    for_each(l.begin(), l.end(), print_element);
    cout << endl;

    //第一个区间元素：1，2
    //第二个区间元素：4，5
    transform(v.begin(), v.begin() + 2, v.begin() + 3, l2.begin(),fun2);
    for_each(l2.begin(), l2.end(), print_element);
    cout << endl;

    return 0;

}

• 测试：
  

• eg：P79\06.cpp

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

void print_element(int n)
{
    cout <<n<<' ';
}

int main(void)
{
    //容器在构造的时候可以不传递参数，也可以传递2个参数，容器中的区间都是是一个闭开区间[)
    //所有STL区间都是闭开区间
    //end应该指向5后面的位置，那么begin就指向1
    //a，a+5迭代器，这俩迭代器实现的方式是类，其内部持有了int*，所以本质上类型是int*
    int a[] = {1, 2, 3, 4, 3};
    vector<int> v(a, a+5);

    //把元素为3的替换成13
    replace(v.begin(), v.end(), 3, 13);

    for_each(v.begin(), v.end(), print_element);
    cout<<endl;
    return 0;

}

• 测试：
  

• eg：P79\07.cpp

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

void print_element(int n)
{
    cout <<n<<' ';
}

int main(void)
{
    //容器在构造的时候可以不传递参数，也可以传递2个参数，容器中的区间都是是一个闭开区间[)
    //所有STL区间都是闭开区间
    //end应该指向5后面的位置，那么begin就指向1
    //a，a+5迭代器，这俩迭代器实现的方式是类，其内部持有了int*，所以本质上类型是int*
    int a[] = {1, 2, 3, 4, 3};
    vector<int> v(a, a+5);
    list<int> l(5);

    //把元素为3的替换成13
    replace(v.begin(), v.end(), 3, 13);

    for_each(v.begin(), v.end(), print_element);
    cout<<endl;

    //replace_copy原区间不改，目标区间会更改
    replace_copy(v.begin(), v.end(), l.begin(), 13, 3);
    for_each(v.begin(), v.end(), print_element);
    cout<<endl;
    
    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    return 0;

}

• 测试：
  

• eg：P79\08.cpp

#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
using namespace std;

void print_element(int n)
{
    cout <<n<<' ';
}

bool func(int n)
{
    return n < 10;
}

int main(void)
{
    //容器在构造的时候可以不传递参数，也可以传递2个参数，容器中的区间都是是一个闭开区间[)
    //所有STL区间都是闭开区间
    //end应该指向5后面的位置，那么begin就指向1
    //a，a+5迭代器，这俩迭代器实现的方式是类，其内部持有了int*，所以本质上类型是int*
    int a[] = {1, 2, 3, 4, 3};
    vector<int> v(a, a+5);
    list<int> l(5);

    //把元素为3的替换成13
    replace(v.begin(), v.end(), 3, 13);

    for_each(v.begin(), v.end(), print_element);
    cout<<endl;

    //replace_copy原区间不改，目标区间会更改
    replace_copy(v.begin(), v.end(), l.begin(), 13, 3);
    for_each(v.begin(), v.end(), print_element);
    cout<<endl;
    
    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    //拷贝的过程中根据某个条件来替换
    //<10的元素都替换为0
    replace_copy_if(v.begin(), v.end(), l.begin(), func, 0);
    for_each(l.begin(), l.end(), print_element);
    cout<<endl;

    return 0;

}

• 测试：