cb38a_c++_STL_算法_transform

cb38a_c++_STL_算法_transform
transform()算法有两种形式：
transform(b1,e1,b2,op);//b1（源区间）的数据通过op函数处理，存放在b2（目标区间）
transform(b1,e1,b2,b3,op)//把b1,b2结合一起通过op函数处理，存放到b3

注意：
1.如果目标与源相同，transform()就和for_each()一样
2.如果想以某值替换符合规则的元素，应该使用replace()算法。


transform在指定的范围内应用于给定的操作，并将结果存储在指定的另一个范围内。transform函数包含在<algorithm>头文件中。

以下是std::transform的两个声明，

一元操作：

template <class InputIterator, class OutputIterator, class UnaryOperation>

OutputIterator transform (InputIterator first1, InputIterator last1,OutputIterator result, UnaryOperation op);
对于一元操作，将op应用于[first1, last1]范围内的每个元素，并将每个操作返回的值存储在以result开头的范围内。给定的op将被连续调用last1-first1+1次。

op可以是函数指针或函数对象或lambda表达式。

例如：op的一个实现 即将[first1, last1]范围内的每个元素加5，然后依次存储到result中。

int op_increase(int i) {return (i + 5)};
调用std::transform的方式如下：

std::transform(first1, last1, result, op_increase);
二元操作：

template <class InputIterator1, class InputIterator2,class OutputIterator, class BinaryOperation>
OutputIterator transform (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, OutputIterator result,BinaryOperation binary_op);

对于二元操作，使用[first1, last1]范围内的每个元素作为第一个参数调用binary_op,并以first2开头的范围内的每个元素作为第二个参数调用binary_op,
每次调用返回的值都存储在以result开头的范围内。给定的binary_op将被连续调用last1-first1+1次。binary_op可以是函数指针或函数对象或lambda表达式。

例如：binary_op的一个实现即将first1和first2开头的范围内的每个元素相加，然后依次存储到result中。

int op_add(int, a, int b) {return (a + b)};
调用std::transform的方式如下：

std::transform(first1, last1, first2, result, op_add);

#include <functional> //预定义函数对象
negate<int>() 把一个数变成负数


1>d:program files (x86)microsoft visual studio2017communityvc oolsmsvc14.16.27023includealgorithm(1443):
template<class _InIt,
class _OutIt,
class _Fn> inline
_OutIt transform(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Fn _Func)
{ // transform [_First, _Last) with _Func
_Adl_verify_range(_First, _Last);
auto _UFirst = _Get_unwrapped(_First);
const auto _ULast = _Get_unwrapped(_Last);
auto _UDest = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
for (; _UFirst != _ULast; ++_UFirst, (void)++_UDest)
{
*_UDest = _Func(*_UFirst);
}

_Seek_wrapped(_Dest, _UDest);
return (_Dest);
}

使用预定义函数对象有2个参数是，需要使用预定义函数对象适配器，bind2nd
bind2nd(multiplies<int>(),10)
//error C2065: “ostream_iterator”: 未声明的标识符,未包含#include<iterator>

  1 /*cb38a_c++_STL_算法_transform
  2 transform()算法有两种形式：
  3 transform(b1,e1,b2,op);//b1（源区间）的数据通过op函数处理，存放在b2（目标区间）
  4 transform(b1,e1,b2,b3,op)//把b1,b2结合一起通过op函数处理，存放到b3
  5 
  6 注意：
  7 1.如果目标与源相同，transform()就和for_each()一样
  8 2.如果想以某值替换符合规则的元素，应该使用replace()算法。
  9 
 10 
 11 transform在指定的范围内应用于给定的操作，并将结果存储在指定的另一个范围内。transform函数包含在<algorithm>头文件中。
 12 
 13 以下是std::transform的两个声明，
 14 
 15 一元操作：
 16 
 17 template <class InputIterator, class OutputIterator, class UnaryOperation>
 18 
 19 OutputIterator transform (InputIterator first1, InputIterator last1,OutputIterator result, UnaryOperation op);
 20 对于一元操作，将op应用于[first1, last1]范围内的每个元素，并将每个操作返回的值存储在以result开头的范围内。给定的op将被连续调用last1-first1+1次。
 21 
 22 op可以是函数指针或函数对象或lambda表达式。
 23 
 24 例如：op的一个实现 即将[first1, last1]范围内的每个元素加5，然后依次存储到result中。
 25 
 26 int op_increase(int i) {return (i + 5)};
 27 调用std::transform的方式如下：
 28 
 29 std::transform(first1, last1, result, op_increase);
 30 二元操作：
 31 
 32 template <class InputIterator1, class InputIterator2,class OutputIterator, class BinaryOperation>
 33 OutputIterator transform (InputIterator1 first1, InputIterator1 last1,InputIterator2 first2, OutputIterator result,BinaryOperation binary_op);
 34 
 35 对于二元操作，使用[first1, last1]范围内的每个元素作为第一个参数调用binary_op,并以first2开头的范围内的每个元素作为第二个参数调用binary_op,
 36 每次调用返回的值都存储在以result开头的范围内。给定的binary_op将被连续调用last1-first1+1次。binary_op可以是函数指针或函数对象或lambda表达式。
 37 
 38 例如：binary_op的一个实现即将first1和first2开头的范围内的每个元素相加，然后依次存储到result中。
 39 
 40 int op_add(int, a, int b) {return (a + b)};
 41 调用std::transform的方式如下：
 42 
 43 std::transform(first1, last1, first2, result, op_add);
 44 
 45 #include <functional> //预定义函数对象
 46 negate<int>() 把一个数变成负数
 47 
 48 
 49 1>d:program files (x86)microsoft visual studio2017communityvc	oolsmsvc14.16.27023includealgorithm(1443):
 50 template<class _InIt,
 51     class _OutIt,
 52     class _Fn> inline
 53     _OutIt transform(const _InIt _First, const _InIt _Last, _OutIt _Dest, _Fn _Func)
 54     {    // transform [_First, _Last) with _Func
 55     _Adl_verify_range(_First, _Last);
 56     auto _UFirst = _Get_unwrapped(_First);
 57     const auto _ULast = _Get_unwrapped(_Last);
 58     auto _UDest = _Get_unwrapped_n(_Dest, _Idl_distance<_InIt>(_UFirst, _ULast));
 59     for (; _UFirst != _ULast; ++_UFirst, (void)++_UDest)
 60         {
 61         *_UDest = _Func(*_UFirst);
 62         }
 63 
 64     _Seek_wrapped(_Dest, _UDest);
 65     return (_Dest);
 66     }
 67 
 68     使用预定义函数对象有2个参数是，需要使用预定义函数对象适配器，bind2nd
 69      bind2nd(multiplies<int>(),10)
 70  //error C2065: “ostream_iterator”: 未声明的标识符,未包含#include<iterator>
 71 
 72 */
 73 
 74 #include <iostream>
 75 #include <algorithm>
 76 #include <vector>
 77 #include <list>
 78 #include <functional> //预定义函数对象
 79 #include <iterator>
 80 
 81 using namespace std;
 82 
 83 int main()
 84 {
 85     vector<int> ivec;
 86     list<int> ilist;
 87     for (int i = 1; i <= 9; ++i)
 88         ivec.push_back(i);
 89     for (vector<int>::iterator iter = ivec.begin(); iter != ivec.end(); ++iter)
 90         cout << *iter << ' ';
 91     cout << endl;
 92 
 93     //transfrom自己把自己的数修改为负数
 94 
 95     transform(ivec.begin(), ivec.end(), ivec.begin(), negate<int>());//negate<int>() 把一个数变成负数
 96     for (vector<int>::iterator iter = ivec.begin(); iter != ivec.end(); ++iter)
 97         cout << *iter << ' ';
 98     cout << endl;
 99 
100     transform(ivec.begin(), ivec.end(), back_inserter(ilist), bind2nd(multiplies<int>(),10));////预定义函数对象,每个数乘以10
101 
102     cout << "预定义函数对象,每个数乘以10" << endl;
103     for (list<int>::iterator iter = ilist.begin(); iter != ilist.end(); ++iter)
104         cout << *iter << ' ';
105     cout << endl;
106 
107     cout << "先把list取负，再把数据指定到cout输出流里面" << endl;
108 
109     transform(ilist.begin(), ilist.end(), ostream_iterator<int>(cout, " "), negate<int>());
110     return 0; 
111 }
 1 /*cb38b_c++_STL_算法_transform
 2 transform()算法有两种形式：
 3 transform(b1,e1,b2,op);//b1（源区间）的数据通过op函数处理，存放在b2（目标区间）
 4 transform(b1,e1,b2,b3,op)//把b1,b2结合一起通过op函数处理，存放到b3
 5 
 6 //自己和自己相加，放入ilist容器里面。
 7     transform(ivec.begin(), ivec.end(), ivec.begin(), back_inserter(ilist), plus<int>());
 8     //
 9 
10     error C2955: “std::ostream_iterator”: 使用 类 模板 需要 模板 参数列表
11 
12     ostream_iterator(cout, " "),
13     ostream_iterator<int>(cout, " "),忘记写<int>
14 */
15 
16 #include <iostream>
17 #include <vector>
18 #include <list>
19 #include <algorithm>
20 #include <iterator>
21 
22 using namespace std;
23 
24 int main()
25 {
26     vector<int> ivec;
27     list<int> ilist;
28     for (int i = 1; i <= 9; ++i)
29         ivec.push_back(i);
30     for (vector<int>::iterator iter = ivec.begin(); iter != ivec.end(); ++iter)
31         cout << *iter << ' ';
32     cout << endl;
33 
34     cout << "容器自己内部数据操作，操作后还是放回自己的容器,自己和自己相乘" << endl;
35     transform(ivec.begin(), ivec.end(), ivec.begin(), ivec.begin(), multiplies<int>());
36     for (vector<int>::iterator iter = ivec.begin(); iter != ivec.end(); ++iter)
37         cout << *iter << ' ';
38     cout << endl;
39 
40     //自己和自己相加，放入ilist容器里面。
41     transform(ivec.begin(), ivec.end(), ivec.begin(), back_inserter(ilist), plus<int>());
42     //
43     cout << "//自己和自己相加，放入ilist容器里面。" << endl;
44     for (list<int>::iterator iter = ilist.begin();  iter!= ilist.end(); ++iter)
45         cout << *iter << ' ';
46     cout << endl;
47 
48     cout << "通过transform向量与list相减，放入ilist容器里面，用cout输出" << endl;
49     transform(ivec.begin(), ivec.end(), ilist.begin(), ostream_iterator<int>(cout, " "), minus<int>());
50 
51     
52     return 0;
53 
54 }
欢迎讨论，相互学习。 txwtech@163.com
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/txwtech/p/12350238.html