【C++】STL 算法 ⑤ ( 二元函数对象 | std::transform 算法简介 | 为 std::transform 算法传入一元函数对象进行转换操作 )

男娘i 2024-02-05 22:30 28阅读 0赞

#### 文章目录 ####

*  一、二元函数对象
 *   *  1、二元函数对象简介
     *  2、std::transform 算法简介
     *  3、代码示例 - 为 std::transform 算法传入一元函数对象进行转换操作

## 一、二元函数对象 ##

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

### 1、二元函数对象简介 ###

" 二元函数对象 " 指的是 一个实例类 中 , 重载了 " 函数调用操作符 () " 函数 operator() , 并且该函数 接受 2 个参数 ;

如果 " 重载 函数调用操作符 () 函数 " 只接收一个参数 , 那么这个函数对象就是 一元函数对象 ;

下面的结构体类 函数对象 , 就是一个二元函数对象 , 其作用是将传入的两个 int 参数相加并返回 ;

struct Add {
          
        int operator()(int a, int b) const {
          
            return a + b;  
        }  
    };

### 2、std::transform 算法简介 ###

std::transform 是 STL 标准模板库 中的一个算法 , 该算法的作用是 用于对 容器 或 指定迭代器范围 的元素进行 " 转换操作 " , 并将 " 转换结果 " 存储到另一个容器中 ;

std::transform 算法 接受 一个或两个输入范围 , 以及一个输出范围 , 并 根据提供的 一元函数对象 或 二元函数对象 对 " 输入范围内的元素 " 进行转换 ;

**std::transform 函数原型如下 :**

template <class _InIt1, class _InIt2, class _OutIt, class _Fn>
    _OutIt transform(const _InIt1 _First1, const _InIt1 _Last1, const _InIt2 _First2, _OutIt _Dest, _Fn _Func) {
        
        // transform [_First1, _Last1) and [_First2, ...) with _Func
        _Adl_verify_range(_First1, _Last1);
        auto _UFirst1      = _Get_unwrapped(_First1);
        const auto _ULast1 = _Get_unwrapped(_Last1);
        const auto _Count  = _Idl_distance<_InIt1>(_UFirst1, _ULast1);
        auto _UFirst2      = _Get_unwrapped_n(_First2, _Count);
        auto _UDest        = _Get_unwrapped_n(_Dest, _Count);
        for (; _UFirst1 != _ULast1; ++_UFirst1, (void) ++_UFirst2, ++_UDest) {
        
            *_UDest = _Func(*_UFirst1, *_UFirst2);
        }
    
        _Seek_wrapped(_Dest, _UDest);
        return _Dest;
    }

*  **const \_InIt1 \_First1 和 const \_InIt1 \_Last1 参数 :** 第一个输入序列 的 迭代器范围 , \_First1 是 范围起始迭代器 , \_Last1 是 范围结束迭代器 ;
 *  **const \_InIt2 \_First2 参数 :** 定义了 第二个输入序列 的开始迭代器 , 该范围的元素个数 要 大于等于 第一输入序列的 元素个数 ;
 *  **\_OutIt \_Dest 参数 :** 输出序列的 开始位置迭代器 ;
 *  **\_Fn \_Func 参数 :** 函数对象 , 可以是 一元函数对象 或 二元函数对象 ; 
    
     *  **一元函数对象 :** 接受一个参数 , 也就是来自第一个输入序列的元素 , 并返回转换后的值 ;
     *  **二元函数对象 :** 接受两个参数 , 第一个参数是 来自第一个输入序列的元素 , 第二个参数是 第二个输入序列的元素 , 计算完成后返回转换后的值 ;

**transform 转换算法使用示例 :**

// std::transform 算法 接受一个或两个输入范围 , 以及一个输出范围 , 
    	// 并根据提供的  一元函数对象 或 二元函数对象 对 " 输入范围内的元素 " 进行转换
    	transform(vec.begin(), vec.end(), vec2.begin(), vec3.begin(), Add<int>());

**上述传入的二元函数对象为 :**

//函数对象 类重载了()
    template <typename T>
    class Add {
        
    public:
    	int operator()(T& a, T& b) const {
        
    		return a + b;
    	}
    };

### 3、代码示例 - 为 std::transform 算法传入一元函数对象进行转换操作 ###

下面的代码示例中 , 演示了 将 2 个 vector 容器中的元素相加 , 放入到第 3 个容器 中 ;

transform 算法函数 , 接收 2 个输入范围 ,

*  第一个输入范围 是 vec 容器的 起始迭代器 和 结束迭代器 , 这是一个前闭后开区间 ; 第一个输入范围需要有两个迭代器指明该范围内的元素个数 ;
 *  第二个输入范围 是 vec2 容器的 起始迭代器 , 第二个输入范围只需要指明起始迭代器即可 , 因为在第一个输入范围中已经指明了元素个数 , 第二个输入范围的结束位置只需要 起始位置 累加 元素个数 即可 ; 第二个输入范围的元素个数 , 必须大于等于
 *  输出范围 也是 指定 起始迭代器即可 , 其容量必须 大于等于 输入范围 的元素个数 ;

**代码示例 :**

#include "iostream"
    using namespace std;
    #include <vector>
    #include <algorithm>
    #include "functional"
    
    //函数对象 类重载了()
    template <typename T>
    class Add {
        
    public:
    	int operator()(T& a, T& b) const {
        
    		return a + b;
    	}
    };
    
    int main() {
        
    
    	// 创建一个 vector 单端数组容器
    	vector<int> vec;
    	vector<int> vec2;
    	vector<int> vec3;
    	// 向容器中插入元素
    	vec.push_back(1);
    	vec.push_back(2);
    	vec.push_back(3);
    	vec.push_back(4);
    	vec.push_back(5);
    
    	vec2.push_back(6);
    	vec2.push_back(7);
    	vec2.push_back(8);
    	vec2.push_back(9);
    	vec2.push_back(10);
    
    	vec3.resize(5);
    
    	// std::transform 算法 接受一个或两个输入范围 , 以及一个输出范围 , 
    	// 并根据提供的  一元函数对象 或 二元函数对象 对 " 输入范围内的元素 " 进行转换
    	transform(vec.begin(), vec.end(), vec2.begin(), vec3.begin(), Add<int>());
    
    	//容器的遍历
    	cout << "遍历容器 :" << endl;
    	for (auto it = vec3.begin(); it != vec3.end(); it++)
    	{
        
    		cout << *it << " ";
    	}
    	cout << "遍历结束" << endl;
    
    	// 控制台暂停 , 按任意键继续向后执行
    	system("pause");
    	return 0;
    };

**执行结果 :**

vec 中的元素是 1 , 2 , 3 , 4 , 5 ;

vec2 中的元素是 6, 7, 8, 9 , 10 ;

上述两个集合中的元素 , 两两相加 , 放入 vec 3 中 ,

最终的执行结果 如下 :

遍历容器 :
    7 9 11 13 15 遍历结束
    请按任意键继续. . .

![在这里插入图片描述][a3ddf713f4ca484897b9ef8b5cf5fd0e.png]

[a3ddf713f4ca484897b9ef8b5cf5fd0e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/01/30/6b69d8decbbe4250858d9f1e6bfc81fe.png