STL算法 | std::transform函数，将给定范围内的数据按照某种操作后保存在另一个同种类型容器中。

叁歲伎倆 2022-10-24 01:38 15阅读 0赞

[transform][]定义于头文件 <algorithm>，应用给定的函数到范围并存储结果于始于 d\_first 的另一范围。

函数原型

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

**参数**

*  first1, last1 - 要变换的第一元素范围
 *  first2 - 要变换的第二元素范围的起始
 *  d\_first - 目标范围的起始，可以等于 first1 或 first2
 *  unary\_op - 将要应用的一元算符函数。  
    函数签名应等价于如下者：`Ret fun(const Type &a);`  
    签名不必有 const & 。  
    类型 Type 必须使得 InputIt 类型对象能在解引用后隐式转换到 Type 。 类型 Ret 必须使得 OutputIt 类型对象能被解引用并能被赋 Ret 类型值。
 *  binary\_op - 被使用的二元函数对象。  
    该函数的签名应当等价于：`Ret fun(const Type1 &a, const Type2 &b);`  
    签名中并不需要有 const &。  
    类型 Type1 与 Type2 必须使得 InputIt1 与 InputIt2 类型的对象在解引用后分别能隐式转换到 Type1 与 Type2 。 类型 Ret 必须使得 OutputIt 类型对象能被解引用并能被赋 Ret 类型值。

**返回值**  
指向最后一个变换的元素的输出迭代器。

**可能的实现方式：**

版本一

template<class InputIt, class OutputIt, class UnaryOperation>
    OutputIt transform(InputIt first1, InputIt last1, OutputIt d_first, 
                       UnaryOperation unary_op)
    {
        
        while (first1 != last1) {
        
            *d_first++ = unary_op(*first1++);
        }
        return d_first;
    }

版本二

template<class InputIt1, class InputIt2, 
             class OutputIt, class BinaryOperation>
    OutputIt transform(InputIt1 first1, InputIt1 last1, InputIt2 first2, 
                       OutputIt d_first, BinaryOperation binary_op)
    {
        
        while (first1 != last1) {
        
            *d_first++ = binary_op(*first1++, *first2++);
        }
        return d_first;
    }

注:  
std::transform 不保证按顺序应用 unary\_op 或 binary\_op 。为按顺序应用函数到数列，或应用修改序列元素的函数，应使用 std::for\_each 。

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

测试用例

#include <algorithm>
    #include <cctype>
    #include <iostream>
    #include <string>
    #include <vector>
    
    int main()
    {
        
    	std::string s("hello");
    	std::transform(s.begin(), s.end(), s.begin(),//	全部元素转换为大写
    		[](unsigned char c) -> unsigned char {
         return std::toupper(c); });
    
    	std::vector<std::size_t> ordinals;	// 将s中元素的ascii码值插入ordinals
    	std::transform(s.begin(), s.end(), std::back_inserter(ordinals),
    		[](unsigned char c) -> std::size_t {
         return c; });
    
    	std::cout << s << ':';
    	for (auto ord : ordinals) {
        
    		std::cout << ' ' << ord;
    	}
    
    	// 下面语句的意思是：
    	//     从[①, ② ) 范围开始，使用 ⑤ 操作，依次加上 从[③, ...) 开始的
    	//     结果输出到 ④ 中 
    	//
    	//              ①                  ②               ③
    	std::transform(ordinals.cbegin(), ordinals.cend(), ordinals.cbegin(),
    		ordinals.begin(), std::plus<>{
        });
    	//			    ④         ⑤
    
    	std::cout << '\n';
    	for (auto ord : ordinals) {
        
    		std::cout << ord << ' ';
    	}
    	std::cout << '\n';
    }
    
    /*  输出结果
    	HELLO: 72 69 76 76 7
    	144 138 152 152 158
    */

补充几个可以用于此函数的函数对象：

*  plus： 加法函数对象类（类模板）  
    int first\[\] = \{ 1,2,3,4,5 \};  
    int second\[\] = \{ 10,20,30,40,50 \};  
    int results\[5\];  
    std::transform(first, first + 5, second, results, std::plus());  
    // 两数组元素相加，存储在results中，11 22 33 44 55 
 *  minus： 减法函数对象类（类模板）  
    int first\[\] = \{ 1,2,3,4,5 \};  
    int second\[\] = \{ 10,20,30,40,50 \};  
    int results\[5\];  
    std::transform(first, first + 5, second, results, std::minus());  
    // 两数组元素相减，存储在results中，-9 -18 -27 -36 -45
 *  multiplies： 乘法函数对象类（类模板）  
    int first\[\] = \{ 1,2,3,4,5 \};  
    int second\[\] = \{ 10,20,30,40,50 \};  
    int results\[5\];  
    std::transform(first, first + 5, second, results, std::multiplies());  
    // 两数组元素相乘，存储在results中，10 40 90 160 250
 *  divides： 除法函数对象类（类模板）  
    int first\[\] = \{ 10,40,90,40,10 \};  
    int second\[\] = \{ 1,2,3,4,5 \};  
    int results\[5\];  
    std::transform(first, first + 5, second, results, std::divides());  
    // // 两数组元素相除，存储在results中，10 20 30 10 2
 *  modulus： 计算除法余数的函数对象类（类模板）  
     int numbers\[\] = \{ 1,2,3,4,5 \};  
    int remainders\[5\];  
    //std::transform(numbers, numbers + 5, remainders, std::bind2nd(std::modulus(), 2));  
    // 注：binder2nd等函数在C++17以后就已经被弃用了，实现与上面同等功能的语句还可以用匿名函数实现  
    std::transform(numbers, numbers + 5, remainders,  
    \[\](int val) \{return val % 2; \});  
    // 将奇数变成 1， 偶数变成 0 , 结果 1 0 1 0 1
 *  equal\_to： 用于相等比较的函数对象类（类模板）  
    int foo\[\] = \{ 10,20,30,40,50 \};  
    int bar\[\] = \{ 10,20,40,80,160 \};  
    bool res\[5\];  
    std::transform(foo, foo + 5, bar, res, std::equal\_to());  
    // 两数组对应项比较，结果存储在results中，true true false false false
 *  negate： 负函数对象类（类模板）  
    int numbers\[\] = \{ 10,-20,30,-40,50 \};  
    std::transform(numbers, numbers + 5, numbers, std::negate());  
    // 将数字取反， -10 20 -30 40 -50

[transform]: https://zh.cppreference.com/w/cpp/algorithm/transform