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

2024-01-08 09:00:02 浏览数 (1)

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

一、二元函数对象


1、二元函数对象简介

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

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

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

代码语言:javascript复制
struct Add {  
    int operator()(int a, int b) const {  
        return a   b;  
    }  
};

2、std::transform 算法简介

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

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

std::transform 函数原型如下 :

代码语言:javascript复制
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 转换算法使用示例 :

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

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

代码语言:javascript复制
//函数对象 类重载了()
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 容器的 起始迭代器 , 第二个输入范围只需要指明起始迭代器即可 , 因为在第一个输入范围中已经指明了元素个数 , 第二个输入范围的结束位置只需要 起始位置 累加 元素个数 即可 ; 第二个输入范围的元素个数 , 必须大于等于
  • 输出范围 也是 指定 起始迭代器即可 , 其容量必须 大于等于 输入范围 的元素个数 ;
代码语言:javascript复制
	// std::transform 算法 接受一个或两个输入范围 , 以及一个输出范围 , 
	// 并根据提供的  一元函数对象 或 二元函数对象 对 " 输入范围内的元素 " 进行转换
	transform(vec.begin(), vec.end(), vec2.begin(), vec3.begin(), Add<int>());

代码示例 :

代码语言:javascript复制
#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 中 ,

最终的执行结果 如下 :

代码语言:javascript复制
遍历容器 :
7 9 11 13 15 遍历结束
请按任意键继续. . .

0 人点赞