C++探究transform算法

transform函数原型

template<class _InIt,
	class _OutIt,
	class _Fn1> inline
	_OutIt transform(_InIt _First, _InIt _Last,
		_OutIt _Dest, _Fn1 _Func)
	{	// transform [_First, _Last) with _Func
	_DEPRECATE_UNCHECKED(transform, _Dest);
	return (_Transform_no_deprecate(_First, _Last, _Dest, _Func));
	}

template<class _InIt1,
	class _InIt2,
	class _OutIt,
	class _Fn2> inline
	_OutIt transform(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _OutIt _Dest, _Fn2 _Func)
	{	// transform [_First1, _Last1) and [_First2, ...) with _Func
	_DEFINE_DEPRECATE_UNCHECKED(transform);
	_USE_DEPRECATE_UNCHECKED(_First2);
	_USE_DEPRECATE_UNCHECKED(_Dest);
	return (_Transform_no_deprecate(_First1, _Last1, _First2, _Dest, _Func));
	}

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt,
	class _OutTy,
	size_t _OutSize,
	class _Fn1> inline
	_OutTy *transform(_InIt _First, _InIt _Last,
		_OutTy (&_Dest)[_OutSize], _Fn1 _Func)
	{	// transform [_First, _Last) with _Func, array dest
	return (_Unchecked(
		_Transform_no_deprecate(_First, _Last,
			_Array_iterator<_OutTy, _OutSize>(_Dest), _Func)));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

4-6.

 #if _ITERATOR_DEBUG_ARRAY_OVERLOADS
template<class _InIt1,
	class _InTy,
	size_t _InSize,
	class _OutIt,
	class _Fn2> inline
	_OutIt transform(_InIt1 _First1, _InIt1 _Last1,
		_InTy (&_First2)[_InSize], _OutIt _Dest, _Fn2 _Func)
	{	// transform [_First1, _Last1) and [_First2, ...), array input
	_DEPRECATE_UNCHECKED(transform, _Dest);
	return (_Transform_no_deprecate(_First1, _Last1,
		_Array_iterator<_InTy, _InSize>(_First2), _Dest, _Func));
	}

template<class _InIt1,
	class _InIt2,
	class _OutTy,
	size_t _OutSize,
	class _Fn2> inline
	_OutTy *transform(_InIt1 _First1, _InIt1 _Last1,
		_InIt2 _First2, _OutTy (&_Dest)[_OutSize], _Fn2 _Func)
	{	// transform [_First1, _Last1) and [_First2, ...), array dest
	_DEPRECATE_UNCHECKED(transform, _First2);
	return (_Unchecked(
		_Transform_no_deprecate(_First1, _Last1,
			_First2, _Array_iterator<_OutTy, _OutSize>(_Dest), _Func)));
	}

template<class _InIt1,
	class _InTy,
	size_t _InSize,
	class _OutTy,
	size_t _OutSize,
	class _Fn2> inline
	_OutTy *transform(_InIt1 _First1, _InIt1 _Last1,
		_InTy (&_First2)[_InSize], _OutTy (&_Dest)[_OutSize], _Fn2 _Func)
	{	// transform [_First1, _Last1) and [_First2, ...), array input/dest
	return (_Unchecked(
		_Transform_no_deprecate(_First1, _Last1,
			_Array_iterator<_InTy, _InSize>(_First2),
			_Array_iterator<_OutTy, _OutSize>(_Dest), _Func)));
	}
 #endif /* _ITERATOR_DEBUG_ARRAY_OVERLOADS */

暂时只研究前面2种

#include <iostream>
#include<algorithm>
#include <functional>
#include <vector>

using namespace std;
class Ticket
{
public:
	Ticket()
	{
		;
	}
	int num;
	int id;
	char zimu;
};
class MyShow_transform
{
public:
	Ticket* operator()(Ticket* t)
	{
		if (t->zimu == ‘A‘)
		{
			cout << "车号：" << t->num << "座位：" << t->id << "排" << t->zimu << "座" << endl;
			return t;
		}
		t->num = 0;
		return t;
	}
};
void show(Ticket* t)
{
	if(t->num != 0)
		cout<< t->num << "车" << t->id << "排" << t->zimu << "座" << endl;
	return;
}
void test_transform()
{
	vector<Ticket*> v1,v2,v3;

	for (int num = 0; num < 2; num++)
	{
		for (int id = 0; id < 5; id++)
		{
			for (int i = 0; i < 5; i++)
			{
				Ticket *tmp = new Ticket;
				tmp->num = num+1;
				tmp->id = id+1;
				tmp->zimu = ‘A‘ + i;
				v1.push_back(tmp);
			}
		}
	}
	v2.resize(v1.size());
	transform(v1.begin(), v1.end(), v2.begin(),MyShow_transform() );
	cout << "-------------------------------------------------------------------" << endl;
	for_each(v2.begin(), v2.end(), show);
	for (vector<Ticket*>::iterator it = v1.begin(); it != v1.end(); )
	{
		delete (*it);
		it = v1.erase(it);
		it++;
	}
}

增加函数适配器

#include <iostream>
#include<algorithm>
#include <functional>
#include <vector>

using namespace std;
class Ticket
{
public:
	Ticket()
	{
		;
	}
	int num;
	int id;
	char zimu;
};
class MyShow_transform : public std::binary_function<Ticket*, char, Ticket*>
{
public:
	Ticket* operator()(const Ticket* t, const char c)const
	{
		Ticket* p = nullptr;
		if (t->zimu == c)
		{
			cout << "车号：" << t->num << "座位：" << t->id << "排" << t->zimu << "座" << endl;
			p = const_cast<Ticket *>(t);
			return p;
		}
		if(p != nullptr)
			p->num = 0;
		return p;
	}
};
void show(Ticket* t)
{
	if (t == nullptr)
		return;
	if(t->num != 0)
		cout<< t->num << "车" << t->id << "排" << t->zimu << "座" << endl;
	return;
}
void test_transform()
{
	vector<Ticket*> v1,v2,v3;

	for (int num = 0; num < 2; num++)
	{
		for (int id = 0; id < 5; id++)
		{
			for (int i = 0; i < 5; i++)
			{
				Ticket *tmp = new Ticket;
				tmp->num = num+1;
				tmp->id = id+1;
				tmp->zimu = ‘A‘ + i;
				v1.push_back(tmp);
			}
		}
	}
	v2.resize(v1.size());
	transform(v1.begin(), v1.end(), v2.begin(),bind2nd( MyShow_transform(),‘A‘ ));
	cout << "-------------------------------------------------------------------" << endl;
	for_each(v2.begin(), v2.end(), show);
	for (vector<Ticket*>::iterator it = v1.begin(); it != v1.end(); )
	{
		delete (*it);
		it = v1.erase(it);
		it++;
	}
}

void main()
{
	test_transform();
	cout << endl;
	cout << "hello" << endl;
	system("pause");
}

2.增加一个vector

#include <iostream>
#include<algorithm>
#include <functional>
#include <vector>

using namespace std;
class Ticket
{
public:
	Ticket()
	{
		;
	}
	int num;
	int id;
	char zimu;
};
class MyShow_transform : public std::binary_function<Ticket*, char, Ticket*>
{
public:
	Ticket* operator()(const Ticket* t, const char c)const
	{
		Ticket* p = nullptr;
		if (t->zimu == c)
		{
			cout << "车号：" << t->num << "座位：" << t->id << "排" << t->zimu << "座" << endl;
			p = const_cast<Ticket *>(t);
			return p;
		}
		if(p != nullptr)
			p->num = 0;
		return p;
	}
};
class MyShow_transformadv : public std::binary_function<Ticket*, Ticket*, Ticket*>
{
public:
	Ticket* operator()(const Ticket* t1, const Ticket* t2)const
	{
		Ticket* p = nullptr;
		p = const_cast<Ticket *>(t1);
		if (t2 == nullptr)
			return p;
		if (t1->num == t2->num)
		{
			cout << "车号：" << t1->num << "座位：" << t1->id << "排" << t1->zimu << "座" << endl;
			return p;
		}
		if (p != nullptr)
			p->num = 0;
		return p;
	}
};
void show(Ticket* t)
{
	if (t == nullptr)
		return;
	if(t->num != 0)
		cout<< t->num << "车" << t->id << "排" << t->zimu << "座" << endl;
	return;
}
void test_transform()
{
	vector<Ticket*> v1,v2,v3;

	for (int num = 0; num < 2; num++)
	{
		for (int id = 0; id < 5; id++)
		{
			for (int i = 0; i < 5; i++)
			{
				Ticket *tmp = new Ticket;
				tmp->num = num+1;
				tmp->id = id+1;
				tmp->zimu = ‘A‘ + i;
				v1.push_back(tmp);
			}
		}
	}
	v2.resize(v1.size());
	cout << "v2-------------------------------------------------------------------" << endl;
	transform(v1.begin(), v1.end(), v2.begin(),bind2nd( MyShow_transform(),‘A‘ ));
	v3.resize(v1.size());
	cout << "v3-------------------------------------------------------------------" << endl;
	transform(v1.begin(), v1.end(), v2.begin(),v3.begin(), MyShow_transformadv());
	cout << "-------------------------------------------------------------------" << endl;

	for (vector<Ticket*>::iterator it = v1.begin(); it != v1.end(); )
	{
		delete (*it);
		it = v1.erase(it);
		it++;
	}
}

void main()
{
	test_transform();
	cout << endl;
	cout << "hello" << endl;
	system("pause");
}

原文地址：https://www.cnblogs.com/smh2015/p/9743191.html

时间： 2024-10-18 01:42:09

C++探究transform算法的相关文章

[转]STL transform算法中使用toupper函数

原文转自 http://blog.csdn.net/justin12zhu/article/details/5649236 今天需要实现一个把小写字母转换为大写字母的函数,由于传入的参数是STL中的string类,所以第一想法就是用transform算法来实现这功能,但是报错了.回家之后写了下面一个测试代码来看看到底错在哪里和怎么解决. #include <iostream> #include <algorithm> #include <cctype> using na

transform算法

transform()的第一版本以仿函数op作用于[first,last)中的每一个元素身上,并以其结果产生出一个新序列.第二版本以仿函数binary_op作用于一双元素身上(其中一个元素来自[first1,last1),另一个元素来自"从first2开始的序列"),并以其结果产生出一个新序列.如果第二序列的元素少于第一序列,执行结果未可预期. //版本一 template <class InputIterator,class OutputIterator,class Un

C++11 lambda表达式在for_each和transform算法下的使用

以前,在lambda表达式没有进入标准的时候,对容器的遍历等涉及到使用函数指针的情况,一般人会懒得使用std::for_each,或std::transform,也许只是一个短短的几句话,却要单独写个函数,或函数对象,写的代码反而不如自己用for循环来的快. 但是,C++11引入了lambda表达式后,一切都变的简单了! 1.lambda表达式 lambda表达式是一个匿名函数,用它可以非常方便的表示一个函数对象,先简单说一下lambda表达式,下面这张图表示了C++11中lambda表达式的写

C++探究foreach算法

for_each在algorithm.h 中 template<class _InIt, class _Fn1> inline _Fn1 for_each(_InIt _First, _InIt _Last, _Fn1 _Func) { // perform function for each element _DEBUG_RANGE_PTR(_First, _Last, _Func); _For_each_unchecked(_Unchecked(_First), _Unchecked(_L

STL经常使用遍历算法for_each和transform的比較

for_each()和transform()算法比較 1)STL 算法 – 改动性算法 for_each() copy() copy_backward() transform() merge() swap_ranges() fill() fill_n() generate() generate_n() replace replace_if() replace_copy() replace_copy_if() 2) for_each() 速度快不灵活 transform() 速度慢很灵活普通

STL常用遍历算法for_each和transform的比较

for_each()和transform()算法比较 1)STL 算法 – 修改性算法 for_each() copy() copy_backward() transform() merge() swap_ranges() fill() fill_n() generate() generate_n() replace replace_if() replace_copy() replace_copy_if() 2) for_each() 速度快不灵活 transform() 速度慢非常灵活一

stl变易算法（二）

本篇接着前篇stl变易算法(一)继续讲述变易算法.主要介绍transform.replace.replace_if.replace_copy以及replace_copy_if的用法及实现代码,并给出测试用例. 元素变换transform transform算法用于实行容器元素的变换操作.如下两个使用原型,一个将迭代器区间[first,last)中元素,执行一元函数对象op操作,变换后的结果存放在[result,result+(last-first))区间中.另一个将迭代器区间[first1,la

计算机视觉目标跟踪的算法分类

摘自百度百科............. (1)基于区域的跟踪算法基于区域的跟踪算法基本思想是:将目标初始所在区域的图像块作为目标模板,将目标模板与候选图像中所有可能的位置进行相关匹配,匹配度最高的地方即为目标所在的位置.最常用的相关匹配准则是差的平方和准则,(Sum of Square Difference,SSD). 起初,基于区域的跟踪算法中所用到的目标模板是固定的,如 Lucas 等人提出 Lucas-Kanade 方法,该方法利用灰度图像的空间梯度信息寻找最佳匹配区域,确定目标位置.之

STL的容器算法迭代器的设计理念

1) STL的容器通过类模板技术,实现数据类型和容器模型的分离. 2) STL的迭代器技术实现了遍历容器的统一方法:也为STL的算法提供了统一性. 3) STL的函数对象实现了自定义数据类型的算法运算核心思想:其实函数对象本质就是回调函数,回调函数的思想,就是任务的编写者和任务的调用者有效解耦合,函数指针做函数参数. 4) 具体例子:transform算法的输入,通过迭代器first和last指向的元算作为输入:通过result作为输出:通过函数对象来做自定义数据类型的运算. 版权声明:本文为