C++:泛型算法和函数对象

已于 2022-02-05 14:31:15 修改
阅读量143 收藏
点赞数 3
分类专栏： C++ 文章标签： c++
于 2021-11-30 07:26:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48580892/article/details/121576034
版权

泛型算法

1.copy

#include<iostream>
#include<algorithm>
#include<functional>
#include<vector>
using namespace std;

//copy
template<typename IT,typename INSERT_IT>//顺序型迭代器&插入类型迭代器
//void mcopy(IT first, IT last, INSERT_IT insert_it)//前面包括数据，后面不包括
void mcopy(const IT& first, const IT& last, INSERT_IT insert_it)//前面包括数据，后面不包括
{
	IT tmp = first;
	while (tmp != last)
	{
		*insert_it = *tmp;
		tmp++;
	}
}

int main()
{
	vector<int>v1;
	for (int i = 0; i < 10 ; i++)
	{
		v1.push_back(i);
	}
	mcopy(v1.begin(), v1.end(), ostream_iterator<int>(cout, "  "));
	cout << endl;

	vector<int>v2;
	mcopy(v1.begin(), v1.end(), inserter(v2, v2.begin()));//将v1数据拷贝到v2指定位置
	mcopy(v2.begin(), v2.end(), ostream_iterator<int>(cout, "  "));
	return 0;
}

在这里插入图片描述
2.find

#include<iostream>
#include<algorithm>
#include<functional>
#include<vector>
using namespace std;


//copy
template<typename IT,typename INSERT_IT>//顺序型迭代器&插入类型迭代器
//void mcopy(IT first, IT last, INSERT_IT insert_it)//前面包括数据，后面不包括
void mcopy(const IT& first, const IT& last, INSERT_IT insert_it)//前面包括数据，后面不包括
{
	IT tmp = first;
	while (tmp != last)
	{
		*insert_it = *tmp;
		tmp++;
	}
}

//find
template<typename IT,typename T>
IT mfind(const IT& first, const IT& last, const T& val)
{
	IT tmp = first;
	while (tmp != last)
	{
		if (*tmp == val)
		{
			return tmp;
		}
		tmp++;
	}
	return last;
}

//swap
template<typename T>
void mswap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

//less(函数对象，函数对象本质上是一个对象，使用时候同函数用法一样，因为它重载了括号运算符)
template<typename T>
class Mless
{
public:
	bool operator()(T a,T b)//重载括号运算符
	{
		cout << "bool operator()(T a,T b)" << endl;
		return a < b;
	}
};

//less
template<typename T>
bool mless(T& a, T& b)
{
	return a < b;
}

//sort(可以正序逆序排序)
template<typename IT, typename PRE>
void msort(const IT& first, const IT& last, PRE pre)
{
	for (IT tmp1 = first; tmp1 != last; tmp1++)
	{
		for (IT tmp2 = tmp1 + 1; tmp2 != last; tmp2++)
		{
			if (!pre(*tmp1, *tmp2))
			{
				mswap(*tmp1, *tmp2);
			}
		}
	}
}


int main()
{
	vector<int>v1;
	for (int i = 10; i > 0; i--)
	{
		v1.push_back(i);
	}
	mcopy(v1.begin(), v1.end(), ostream_iterator<int>(cout, "  "));
	cout << endl;

	vector<int>v2;
	mcopy(v1.begin(), v1.end(), inserter(v2, v2.begin()));//将v1数据拷贝到v2指定位置
	mcopy(v2.begin(), v2.end(), ostream_iterator<int>(cout, "  "));
	cout << endl;

	vector<int>::iterator it = mfind(v1.begin(), v1.end(), 5);
	if (it == v1.end())
	{
		cout << "not find" << endl;
	}
	else
	{
		cout << *it << endl;
	}

	//从小到大排序
	msort(v1.begin(), v1.end(), Mless<int>());
	mcopy(v1.begin(), v1.end(), ostream_iterator<int>(cout, "  "));

	Mless<int> _less;
	_less(10, 20);


	return 0;
}

在这里插入图片描述
3.绑定器

#include<iostream>
#include<algorithm>
#include<functional>
#include<vector>
using namespace std;


//copy
template<typename IT,typename INSERT_IT>//顺序型迭代器&插入类型迭代器
//void mcopy(IT first, IT last, INSERT_IT insert_it)//前面包括数据，后面不包括
void mcopy(const IT& first, const IT& last, INSERT_IT insert_it)//前面包括数据，后面不包括
{
	IT tmp = first;
	while (tmp != last)
	{
		*insert_it = *tmp;
		tmp++;
	}
}

//find
template<typename IT,typename T>
IT mfind(const IT& first, const IT& last, const T& val)
{
	IT tmp = first;
	while (tmp != last)
	{
		if (*tmp == val)
		{
			return tmp;
		}
		tmp++;
	}
	return last;
}

//查找一下第一个小于10的元素
template<typename IT, typename PRE>
IT mfind_if(const IT& first, const IT& last, PRE pre)//传入绑定器对象
{
	IT tmp = first;
	while (tmp != last)//遍历每一个数据传入到绑定器对象里面
	{
		//if (*tmp < 10)
		//if (less(*tmp, 10))
		if (pre(*tmp))
		{
			return tmp;
		}
		tmp++;
	}
	return last;
}

//绑定器：给函数对象绑定参数，
template<typename PRE>
class Mbinder2nd
{
public:
	Mbinder2nd(PRE pre,typename PRE::TYPE_SECOND val)
		:_pre(pre), _val(val)
	{

	}

	typename PRE::TYPE_RET operator()(typename PRE::TYPE_FIRST tmp)
	{
		return _pre(tmp, _val);
	}

private:
	PRE _pre;
	typename PRE::TYPE_SECOND _val;
};

//swap
template<typename T>
void mswap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

//less(函数对象，函数对象本质上是一个对象，使用时候同函数用法一样，因为它重载了括号运算符)
template<typename T>
class Mless
{
public:
	typedef T TYPE_FIRST;
	typedef T TYPE_SECOND;
	typedef bool TYPE_RET;
	bool operator()(T a,T b)//重载括号运算符
	{
		cout << "bool operator()(T a,T b)" << endl;
		return a < b;
	}
};

//less
template<typename T>
bool mless(T& a, T& b)
{
	return a < b;
}

//sort(可以正序逆序排序)
template<typename IT, typename PRE>
void msort(const IT& first, const IT& last, PRE pre)
{
	for (IT tmp1 = first; tmp1 != last; tmp1++)
	{
		for (IT tmp2 = tmp1 + 1; tmp2 != last; tmp2++)
		{
			if (!pre(*tmp1, *tmp2))
			{
				mswap(*tmp1, *tmp2);
			}
		}
	}
}


int main()
{
	vector<int>v1;
	for (int i = 10; i > 0; i--)
	{
		v1.push_back(i);
	}
	mcopy(v1.begin(), v1.end(), ostream_iterator<int>(cout, "  "));
	cout << endl;

	vector<int>v2;
	mcopy(v1.begin(), v1.end(), inserter(v2, v2.begin()));//将v1数据拷贝到v2指定位置
	mcopy(v2.begin(), v2.end(), ostream_iterator<int>(cout, "  "));
	cout << endl;

	vector<int>::iterator it = mfind(v1.begin(), v1.end(), 5);
	if (it == v1.end())
	{
		cout << "not find" << endl;
	}
	else
	{
		cout << *it << endl;
	}

	//从小到大排序
	msort(v1.begin(), v1.end(), Mless<int>());
	mcopy(v1.begin(), v1.end(), ostream_iterator<int>(cout, "  "));

	Mless<int> _less;
	_less(10, 20);

	vector<int>::iterator it1 = find_if(v1.begin(), v1.end(), Mbinder2nd<Mless<int>>(Mless<int>(), 10));
	if (it1 == v1.end())
	{
		cout << "not find" << endl;
	}
	else
	{
		cout << *it1 << endl;
	}

	return 0;
}

在这里插入图片描述

#include<iostream>
#include<algorithm>
#include<functional>
#include<vector>
using namespace std;


//copy
template<typename IT,typename INSERT_IT>//顺序型迭代器&插入类型迭代器
//void mcopy(IT first, IT last, INSERT_IT insert_it)//前面包括数据，后面不包括
void mcopy(const IT& first, const IT& last, INSERT_IT insert_it)//前面包括数据，后面不包括
{
	IT tmp = first;
	while (tmp != last)
	{
		*insert_it = *tmp;
		tmp++;
	}
}

//find
template<typename IT,typename T>
IT mfind(const IT& first, const IT& last, const T& val)
{
	IT tmp = first;
	while (tmp != last)
	{
		if (*tmp == val)
		{
			return tmp;
		}
		tmp++;
	}

	return last;
}

//查找一下第一个小于10的元素
template<typename IT, typename PRE>
IT mfind_if(const IT& first, const IT& last, PRE pre)//传入绑定器对象
{
	IT tmp = first;
	while (tmp != last)//遍历每一个数据传入到绑定器对象里面
	{
		//if (*tmp < 10)
		//if (less(*tmp, 10))
		if (pre(*tmp))
		{
			return tmp;
		}
		tmp++;
	}
	return last;
}

//绑定器1
template<typename PRE>
class Mbinder1st
{
public:
	Mbinder1st(PRE pre, typename PRE::TYPE_FIRST val)
		:_pre(pre), _val(val)
	{

	}

	typename PRE::TYPE_RET operator()(typename PRE::TYPE_SECOND tmp)
	{
		return _pre(_val, tmp);
	}

private:
	PRE _pre;
	typename PRE::TYPE_FIRST _val;
};

//绑定器2：给函数对象绑定参数，
template<typename PRE>
class Mbinder2nd
{
public:
	Mbinder2nd(PRE pre,typename PRE::TYPE_SECOND val)
		:_pre(pre), _val(val)
	{

	}

	typename PRE::TYPE_RET operator()(typename PRE::TYPE_FIRST tmp)
	{
		return _pre(tmp, _val);
	}

private:
	PRE _pre;
	typename PRE::TYPE_SECOND _val;
};

//swap
template<typename T>
void mswap(T& a, T& b)
{
	T tmp = a;
	a = b;
	b = tmp;
}

//less(函数对象，函数对象本质上是一个对象，使用时候同函数用法一样，因为它重载了括号运算符)
template<typename T>
class Mless
{
public:
	typedef T TYPE_FIRST;
	typedef T TYPE_SECOND;
	typedef bool TYPE_RET;
	bool operator()(T a,T b)//重载括号运算符
	{
		cout << "bool operator()(T a,T b)" << endl;
		return a < b;
	}
};

//less
template<typename T>
bool mless(T& a, T& b)
{
	return a < b;
}

//sort(可以正序逆序排序)
template<typename IT, typename PRE>
void msort(const IT& first, const IT& last, PRE pre)
{
	for (IT tmp1 = first; tmp1 != last; tmp1++)
	{
		for (IT tmp2 = tmp1 + 1; tmp2 != last; tmp2++)
		{
			if (!pre(*tmp1, *tmp2))
			{
				mswap(*tmp1, *tmp2);
			}
		}
	}
}


int main()
{
	vector<int>v1;
	for (int i = 10; i > 0; i--)
	{
		v1.push_back(i);
	}
	mcopy(v1.begin(), v1.end(), ostream_iterator<int>(cout, "  "));
	cout << endl;

	vector<int>v2;
	mcopy(v1.begin(), v1.end(), inserter(v2, v2.begin()));//将v1数据拷贝到v2指定位置
	mcopy(v2.begin(), v2.end(), ostream_iterator<int>(cout, "  "));
	cout << endl;

	vector<int>::iterator it = mfind(v1.begin(), v1.end(), 5);
	if (it == v1.end())
	{
		cout << "not find" << endl;
	}
	else
	{
		cout << *it << endl;
	}
	less<int>();

	//从小到大排序
	msort(v1.begin(), v1.end(), Mless<int>());
	mcopy(v1.begin(), v1.end(), ostream_iterator<int>(cout, "  "));

	Mless<int> _less;
	_less(10, 20);

	vector<int>::iterator it1 = mfind_if(v1.begin(), v1.end(), Mbinder2nd<Mless<int>>(Mless<int>(), 2));
	vector<int>::iterator it1 = mfind_if(v1.begin(), v1.end(), bind2nd(less<int>(), 2));//用函数封装类模板


	if (it1 == v1.end())
	{
		cout << "not find" << endl;
	}
	else
	{
		cout << *it1 << endl;
	}

	return 0;
}
何小柒（qi)～
关注
专栏目录
【C++】二十四、标准模板库STL之泛型算法、函数对象、迭代器
qq_43411555的博客
08-05 600
一、泛型算法 （一）基本概念 （二）练习1：打印容器元素 （三）练习2：查找容器元素 二、函数对象 （一）概念 （二）函数对象结合泛型算法 （三）函数对象和泛型算法结合的练习1：实现查找大于，小于的数 （四）函数对象和泛型算法结合的练习2：排序 三、迭代器 （一）按照定义划分 （二）按照常性划分 （三）按照功能划分 1. 反转型(反向型)迭代器 2. 插入型迭代器 3. 流式迭代器
C++（十七）：STL之函数对象与算法
xws__meizhong的博客
12-18 871
函数对象和算法 1.函数对象 1.1 概念 所谓函数对象，即时由重载了函数调用操作符的类所创建的对象。函数对象在使用重载的()时，行为类似于函数调用，故而也叫做仿函数。 所以，函数对象的本质是一个类，而非函数。 1.2 使用 函数对象在使用的时候具有以下特点： 函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值； 函数对象超出普通函数的概念，可以有自己的成员、状态； 函数对象可以作为参数传递。 下面是示例： class MyClass { public: MyClass() {
C++ 理解函数对象与lambda表达式
ZhangPY的专栏
08-04 2537
参考《21天学通C++》第21与第22章节，对函数对象进行介绍，同时通过lambda表达式这一匿名函数对象的简洁方式加深对函数对象的理解。本篇博文的主要内容是： （1） 函数对象的概念； （2） 将函数对象用作谓词； （3） 如何使用函数对象实现一元、二元谓词； （4） 如何编写lambda表达式； （5） 如何将lambda表达式用作谓词； （6） 如何编写可存储和可操作状态的lam
C++中函数对象的使用
ZQGet的专栏
10-27 3674
函数对象的使用 利用C++标准模板库的算法可以为我们减轻许多负担，但这些算法大都需要函数或函数对象作为参数，比如用于排序的sort算法，它的接口定义如下：template void sort (RandomAccessIterator first,            RandomAccessIterator last);template void sort (Ran
C++学习笔记（day6）(函数对象和一些算法)
XITMan的博客
07-01 1155
STL函数对象 概念：重载函数调用操作符的类，其对象常称为函数对象 函数对象使用重载的（）时，行为类似函数调用，也叫仿函数 本质：函数对象（仿函数）是一个类，不是一个函数 函数对象的使用： 特点：函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值 函数对象超出普通函数的概念，函数对象可以有自己的状态 函数对象可以作为参数传递 谓词 返回bool类型的仿函数称为谓词 如果operator()接收一个参数，那么叫做一元谓词 如果operator()接收两个参数，那么叫做二元谓词 举例：（一元谓词
C++泛型算法的一些总结
09-05
C++泛型算法是编程语言中的一类重要工具，它们提供了高效、通用的处理数据序列的方法，不依赖于特定的数据结构或元素类型。这些算法独立于容器，仅依赖于元素的比较操作，使得代码更加灵活且易于重用。在本文中，...
C++复习五：泛型编程及C++的类型转换
qq_43215212的博客
08-14 1277
文章目录泛型编程函数模板函数模板和普通函数的区别类型转换调用顺序函数模板也可以进行函数重载模板的机制函数的局限性类模板类模板做函数参数指定传入类型参数模板化整体类型化类模板的继承问题类外实现模板类的成员函数类模板的分文件编写类模板和友元函数C++类型转换静态转换 static_cast动态转换（dynamic_casT）常量转换（const_cast）重新解释转换（reinterpret_cast） 泛型编程 泛型编程是从一个抽象层面描述一种类型的算法，不管容器类型是什么，是一种不同于OOP的角度来抽象具
C++设计新思维：泛型编程与设计模式之应用
01-14
通过模板（templates），C++可以创建泛型函数和泛型类，如STL（标准模板库）中的容器、算法和迭代器就是泛型编程的典型应用。学习泛型编程能够帮助程序员编写出更加灵活、高效且可维护的代码。 1. 模板基础：了解...
C++泛型编程：函数对象(仿函数)和谓词的概念、常见内建函数对象
星辰大海的博客
04-26 452
学习标准库STL，就不得不去了解函数对象和谓词，于是本人今天写篇博客简要介绍。 函数对象 概念：重载函数调用操作符的类，其对象称为函数对象。函数对象使用重载的()时，行为类似函数调用，因此也称为仿函数。另外，仿函数并不是类的特权，在结构体中也可以通过重载()实现仿函数。 本质：是一个类，或是一个结构体，不是一个函数。 使用特点： 1.函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回...
c语言中mcopy的用法,memcpy用法(示例代码)
weixin_28778005的博客
05-24 700
函数原型void *memcpy(void*dest, const void *src, size_t n);功能由src指向地址为起始地址的连续n个字节的数据复制到以destin指向地址为起始地址的空间内。头文件#include返回值函数返回一个指向dest的指针。说明1.source和destin所指内存区域不能重叠，函数返回指向destin的指针。2.与strcpy相比，memcpy并不是遇...
C++拷贝函数详解
eva0919的专栏
07-29 798
<br />1.什么是拷贝构造函数：<br />CA(const CA& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。<br />    当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：<br
关于C++的学习（1）字符串实现
weixin_43542427的博客
07-11 2381
初次涉及C++语言的书写任务。 1、 描述 给定n个字符串（从1开始编号），每个字符串中的字符位置从0开始编号，长度为1-500，现有如下若干操作： copy N X L：取出第N个字符串第X个字符开始的长度为L的字符串。 add S1 S2：判断S1，S2是否为0-99999之间的整数，若是则将其转化为整数做加法，若不是，则作字符串加法，返回的值为一字符串。 find S N：在第N个字符串中从...
拷贝构造函数
weixin_33802505的博客
10-19 194
2019独角兽企业重金招聘Python工程师标准>>> ...
C++入门教程（二十二）：编码、字符和字符串
小古银的博客
04-02 1030
小古银的官方网站（完整教程）：http://www.xiaoguyin.com/ C++入门教程视频：https://www.bilibili.com/video/av20868986/ 目录 目录 编码 普通字符 基础示例 基础讲解 转义字符 字符串 基础示例 基础讲解 原生字符串 基础示例 基础讲解 补充知识（了解即可） 编码 之前提到的ASCII就是...
c++泛型算法，函数对象
sun
11-26 142
目录 泛型算法 1.copy: 2.find: 3.sort()（用到函数对象）//从小到大排 4.greater（）//从大到小排 5.find_if 函数对象（和泛型算法结合使用） 1.less 2.greter 3.binder1st 4.binder2nd 泛型算法 使用到的头文件 #include<algorithm> #include<functional> 1.copy: 实现对IT类型中对象的拷贝，第三个参数使用了插入型迭代器 .
/bin,/sbin,/usr/bin,/usr/sbin目录的区别
海雷丁的专栏
07-14 527
转自：http://www.2cto.com/os/201211/170994.html 在Linux下万恶
C++ copy()函数
清风皓月长歌
08-10 7066
function template std::copy template OutputIterator copy (InputIterator first, InputIterator last, OutputIterator result); Copy range of elements Copies the elements in the range [f
c++中内存拷贝函数(C++ memcpy)详解
热门推荐
Guo_guo
09-17 11万+
原型：void*memcpy(void*dest, const void*src,unsigned int count);  功能：由src所指内存区域复制count个字节到dest所指内存区域。   说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。     举例：            // memcpy.c
C++ STL入门：泛型算法与容器解析
STL，全称为Standard Template Library，是C++编程语言中的一个核心特性，它提供了一组高效、泛型的编程工具，包括容器、迭代器、算法和仿函数。STL的目标是通过泛型编程来实现代码的复用和高效性，使得开发者能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值