【基础】【四】【函数对象】【常用算法】C++学习日记

最新推荐文章于 2024-09-16 15:03:26 发布
最新推荐文章于 2024-09-16 15:03:26 发布
阅读量178 收藏
点赞数
分类专栏： c++学习日记 文章标签： c++ 基础 函数对象 常用算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35654659/article/details/106750760
版权

C++学习日记

Day 12

函数对象

概念：
    1、重载函数调用操作符()的类，其对象常称为函数对象
    2、函数对象使用重载的()时，行为类似函数调用，也叫仿函数
本质：函数对象(仿函数)是一个类，不是一个函数
特点：
    1、函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
    2、函数对象超出普通函数的概念，函数对象可以有自己的状态
    3、函数对象可以作为参数传递

#include<iostream>
using namespace std;
#include<string>

class MyAdd
{
public:
	MyAdd()
	{
		this->count = 0;
	}
	int operator()(int v1, int v2)
	{
		this->count++;
		return v1 + v2;
	}
	void operator()()
	{
		this->count++;
	}
	int count;
};
// 1、函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值
void test01()
{
	MyAdd myadd;
	cout << myadd(10, 20) << endl;
}
// 2、函数对象可以有自己的状态
void test02()
{
	MyAdd myadd;
	myadd();
	myadd();
	myadd();
	myadd();
	cout << myadd.count << endl;
}
// 3、函数对象可以作为参数传递
void print(MyAdd& myadd)
{
	cout << myadd.count << endl;
}
void test03()
{
	MyAdd myadd;
	print(myadd);
}

int main()
{
	test01();
	test02();
	test03();
	return 0;
}
谓词

概念：
    1、返回bool类型的仿函数称为谓词
    2、如果operator()接受一个参数，那么叫做一元谓词
    3、如果operator()接受两个参数，那么叫做二元谓词

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
class My
{
public:
	bool operator()(int val)
	{
		return val > 5;
	}
	bool operator()(int val1, int val2)
	{
		return val1 > val2;
	}
};
// 一元谓词，查找容器中大于5的数字
void test01()
{
	vector<int> arr;
	for (int i = 0; i < 10; i++)
	{
		arr.push_back(i);
	}
	// find_if函数，找到返回迭代器位置，否则返回end()
	vector<int>::iterator it = find_if(arr.begin(), arr.end(), My());
	if (it == arr.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << *it << endl;
	}

}
// 二元谓词，降序排序
void test02()
{
	vector<int> arr;
	arr.push_back(10);
	arr.push_back(50);
	arr.push_back(40);
	arr.push_back(20);
	arr.push_back(60);
	arr.push_back(70);
	sort(arr.begin(), arr.end(), My());
	for (vector<int>::iterator it = arr.begin(); it != arr.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
}
int main()
{
	test01();
	test02();
	return 0;
}
内建函数对象

用法：
    1、这些仿函数所产生的对象，用法和一般函数完全相同
    2、使用内建函数对象，需要引入头文件#include<functional>

算术仿函数

实现四则运算
其中negate是一元运算，其他都是二元运算
仿函数原型：

template<class T> T plus<T>        // 加法仿函数
template<class T> T minus<T>       // 减法仿函数
template<class T> T multiplies<T>  // 乘法仿函数
template<class T> T divides<T>     // 除法仿函数
template<class T> T modulus<T>     // 取模仿函数
template<class T> T negate<T>      // 取反仿函数

#include<iostream>
using namespace std;
#include<functional>
// 一元运算，取反
void test01()
{
	negate<int>n;
	cout << n(10) << endl;

}
// 二元运算，相加
void test02()
{
	plus<int>n;
	cout << n(10, 20) << endl;
}
int main()
{
	test01();
	test02();
	return 0;
}
关系仿函数

实现关系对比
仿函数原型：

template<class T> bool equal_to<T>       // 等于仿函数
template<class T> bool not_equal_to<T>   // 不等于仿函数
template<class T> bool greater<T>        // 大于仿函数
template<class T> bool greater_equal<T>  // 大于等于仿函数
template<class T> bool less<T>           // 小于仿函数
template<class T> bool less_equal<T>     // 小于等于仿函数

使用 greater实现降序排序，例如

#include<iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include<functional>
int main()
{
	vector<int> arr;
	arr.push_back(10);
	arr.push_back(50);
	arr.push_back(30);
	arr.push_back(40);
	arr.push_back(20);
	sort(arr.begin(), arr.end(), greater<int>());
	for (vector<int>::iterator it = arr.begin(); it != arr.end(); it++)
	{
		cout << *it << " ";
	}
	cout << endl;
	return 0;
}

sort函数有两种重载方式，一种是接收谓词，另一种接收关系仿函数(默认是less)

逻辑仿函数

实现逻辑运算
仿函数原型：

template<class T> bool logical_and<T>  // 逻辑与仿函数
template<class T> bool logical_or<T>   // 逻辑或仿函数
template<class T> bool logical_not<T>  // 逻辑非仿函数

常用算法

由头文件<algorithm> <functional> <numeric>组成
<algorithm>是所有STL头文件中最大的一个，范围涉及到比较、交换、查找、遍历、复制、修改等
<functional> 定义了一些模板类，用以声明函数对象
<numeric> 体积很小，只包含几个在序列上面进行简单数学运算的模板函数

遍历算法

for_each

遍历容器
函数原型：

#include<algorithm>
for_each(iterator beg, iterator end, _func);

_func：函数或函数对象，类似于回调函数，例如

#include<iostream>
using namespace std;
#include <vector>
#include <algorithm>
// 普通函数
void print(int val)
{
	cout << val << " ";
}
// 仿函数
class Print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
int main()
{
	vector<int> arr;
	for (int i = 0; i < 10; i++)
	{
		arr.push_back(i);
	}
	// 普通函数
	for_each(arr.begin(), arr.end(), print);
	cout << endl;
	// 仿函数
	for_each(arr.begin(), arr.end(), Print());
	return 0;
}
transform

搬运容器到另一个容器中
函数原型：

#include<algorithm>
transform(iterator beg1, iterator end1, iterator beg2, _func);

beg1： 源容器开始迭代器
end1： 源容器结束迭代器
beg2： 目标容器开始迭代器
_func：函数或函数对象
例如：

#include<iostream>
using namespace std;
#include <vector>
#include <algorithm>
class Print
{
public:
	void operator()(int val)
	{
		cout << val << " ";
	}
};
class TransForm
{
public:
	int operator()(int val)
	{
		return val + 1;
	}
};
int main()
{
	vector<int> arr;
	for (int i = 0; i < 10; i++)
	{
		arr.push_back(i);
	}
	vector<int> t;
	// 新建的t容器容量为零
	// 需要提前开辟足够空间，多余空间用0填充
	t.resize(arr.size());
	transform(arr.begin(), arr.end(), t.begin(), TransForm());
	for_each(t.begin(), t.end(), Print());
	return 0;
}

查找算法

find

查找元素
查到返回元素的迭代器，否则返回end()
函数原型：

#include<algorithm>
find(iterator beg, iterator end, value);

beg： 容器开始迭代器
end： 容器结束迭代器
value：查找的元素
可以使用内置数据类型，也可以使用自定义数据类型(例如class)，但自定义数据类型需要实现运算符==的重载，例如：

#include<iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <string>
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	bool operator==(const Person& p)
	{
		if (p.m_Name == this->m_Name && p.m_Age == this->m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	string m_Name;
	int m_Age;
};

// 内置数据类型
void test1()
{
	vector<int> arr;
	for (int i = 0; i < 10; i++)
	{
		arr.push_back(i);
	}
	vector<int>::iterator it = find(arr.begin(), arr.end(), 10);
	if (it == arr.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << *it << endl;
	}
}
// 自定义数据类型
void test2()
{
	vector<Person> arr;
	arr.push_back(Person("李四", 20));
	arr.push_back(Person("张三", 18));
	arr.push_back(Person("赵五", 22));
	arr.push_back(Person("王六", 25));
	vector<Person>::iterator it = find(arr.begin(), arr.end(), Person("张三", 18));
	if (it == arr.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "姓名：" << it->m_Name << "  年龄：" << it->m_Age << endl;
	}
}
int main()
{
	// 内置数据类型
	test1();
	// 自定义数据类型
	test2();
	return 0;
}
find_if

按条件查找
查到返回元素的迭代器，否则返回end()
函数原型：

#include<algorithm>
find(iterator beg, iterator end, _Pred);

beg： 容器开始迭代器
end： 容器结束迭代器
_Pred：函数或者是谓词(返回bool类型的仿函数)

#include<iostream>
using namespace std;
#include <vector>
#include <algorithm>
#include <string>
class GreaterFive
{
public:
	bool operator()(int val)
	{
		if (val > 5)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};
class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	bool operator==(const Person& p)
	{
		if (p.m_Name == this->m_Name && p.m_Age == this->m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	string m_Name;
	int m_Age;
};
class Greate20
{
public:
	bool operator()(Person& p)
	{
		return p.m_Age > 20;
	}
};
// 内置数据类型
void test1()
{
	vector<int> arr;
	for (int i = 0; i < 10; i++)
	{
		arr.push_back(i);
	}
	vector<int>::iterator it = find_if(arr.begin(), arr.end(), GreaterFive());
	if (it == arr.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << *it << endl;
	}
}
// 自定义数据类型
void test2()
{
	vector<Person> arr;
	arr.push_back(Person("李四", 20));
	arr.push_back(Person("张三", 18));
	arr.push_back(Person("赵五", 22));
	arr.push_back(Person("王六", 25));
	vector<Person>::iterator it = find_if(arr.begin(), arr.end(), Greate20());
	if (it == arr.end())
	{
		cout << "未找到" << endl;
	}
	else
	{
		cout << "姓名：" << it->m_Name << "  年龄：" << it->m_Age << endl;
	}
}
int main()
{
	// 内置数据类型
	test1();
	// 自定义数据类型
	test2();
	return 0;
}
adjacent_find

查找相邻重复元素
返回相邻重复元素的第一个位置的迭代器
函数原型：

#include<algorithm>
adjacent_find(iterator beg, iterator end);

beg： 容器开始迭代器
end： 容器结束迭代器

binary_search

二分查找法
查找指定元素是否存在，查到返回true，否则返回false
注意：无序序列中不可用
函数原型：

#include<algorithm>
bool binary_search(iterator beg, iterator end, value);

beg： 容器开始迭代器
end： 容器结束迭代器
value：查找的元素

cout

统计元素个数
函数原型：

#include<algorithm>
cout(iterator beg, iterator end, value);

beg： 容器开始迭代器
end： 容器结束迭代器
value：统计的元素
内置数据类型和自定义数据类型，自定义数据类型需要运算符==重载

count_if

按条件统计元素个数
函数原型：

#include<algorithm>
cout_if(iterator beg, iterator end, _Pred);

beg： 容器开始迭代器
end： 容器结束迭代器
_Pred：谓词，bool类型
内置数据类型和自定义数据类型

排序算法

sort

对容器内元素进行排序
按值查找元素，找到返回指定位置迭代器，否则返回end()
函数原型：

#include<algorithm>
sort(iterator beg, iterator end, _Pred);

beg： 容器开始迭代器
end： 容器结束迭代器
_Pred：谓词或內建函数

random_shuffle

洗牌，指定范围内的元素随机调整次序
函数原型：

#include<algorithm>
random_shuffle(iterator beg, iterator end);

beg： 容器开始迭代器
end： 容器结束迭代器
需要加随机数种子，以此来保证每次打乱顺序都不一样

srand((unsigned int)time(NULL));
merge

容器元素合并，并存储到另一容器中
注意：两个容器必须是有序的
函数原型：

#include<algorithm>
merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

beg1： 容器1开始迭代器
end1： 容器1结束迭代器
beg2： 容器2开始迭代器
end2： 容器2结束迭代器
dest：目标容器开始迭代器
注意目标容器需要预设空间

reverse

反转指定范围的元素
函数原型：

#include<algorithm>
reverse(iterator beg, iterator end);

beg： 开始迭代器
end： 结束迭代器

拷贝和替换算法

copy

容器内指定范围内元素拷贝到另一容器中
函数原型：

#include<algorithm>
copy(iterator beg, iterator end, iterator dest);

beg： 开始迭代器
end： 结束迭代器
dest：目标容器起始迭代器
注意目标容器需要预设空间

replace

将容器内指定范围的旧元素修改为新元素
函数原型：

#include<algorithm>
replace(iterator beg, iterator end, oldvalue, newvalue);

beg： 开始迭代器
end： 结束迭代器
oldvalue：旧元素
newvalue：新元素

replace_if

容器内指定范围满足条件的元素替换为新元素
函数原型：

#include<algorithm>
replace_if(iterator beg, iterator end, _Pred, newvalue);

beg： 开始迭代器
end： 结束迭代器
_Pred：谓词
newvalue：新元素

swap

互换两个容器的元素
函数原型：

#include<algorithm>
swap(container c1, container c2);

c1： 容器1
c2： 容器2
注意：同等类型容器

算数生成算法

accumulate

计算区间内容器元素累计总和
函数原型：

#include<numeric>
accumulate(iterator beg, iterator end, value);

beg：开始迭代器
end：结束迭代器
value：起始累加值

fill

向容器中指定区间内填充为指定的元素
函数原型：

#include<numeric>
fill(iterator beg, iterator end, value);

beg：开始迭代器
end：结束迭代器
value：填充的值

集合算法

set_intersection

求两个容器的交集
注意：两个容器必须为有序序列
返回值：目标容器的最后一个元素的迭代器地址，即交集中最后一个元素的位置
函数原型：

#include<algorithm>
set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

beg1：容器1开始迭代器
end1：容器1结束迭代器
beg2：容器2开始迭代器
end2：容器2结束迭代器
dest：目标容器开始迭代器

set_union

求两个容器的并集
注意：两个容器必须为有序序列
返回值：目标容器的最后一个元素的迭代器地址，即并集中最后一个元素的位置
函数原型：

#include<algorithm>
set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

beg1：容器1开始迭代器
end1：容器1结束迭代器
beg2：容器2开始迭代器
end2：容器2结束迭代器
dest：目标容器开始迭代器

ser_difference

求两个容器的差集
注意：两个容器必须为有序序列
返回值：目标容器的最后一个元素的迭代器地址，即差集中最后一个元素的位置
函数原型：

#include<algorithm>
ser_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

beg1：容器1开始迭代器
end1：容器1结束迭代器
beg2：容器2开始迭代器
end2：容器2结束迭代器
dest：目标容器开始迭代器

allin_it
关注
专栏目录
C++学习日记（函数）
michaelzzk的博客
04-11 223
函数的概念 输入——&gt;函数体：完成某种功能——&gt;输出（独立的黑匣子） 在C++中，可以将一段经常使用的代码封装起来，在需要使用时直接调用，这就是程序中的函数。 C++程序的执行是从main函数开始的，如果在main函数中调用了其他函数，在调用后程序返回到main函数，在main函数中结束整个程序的运行。 函数分为：无参函数和有参函数 函数的声明 先声明，后使用。 如果...
八、c++笔记 函数对象
qq_29448131的博客
07-07 840
函数原型:set_intersection(iterator beg1,iterator end1, iterator beg2,iterator end2,iterator dest);函数原型:set_union(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest);template bool less_equal //小于等于。
Turbo C & C++ for Windows 集成实验与学习环境
03-18
Turbo C & C++ for Windows 集成实验与学习环境 中文版的c语言学习软件 非常适合想学习c语言的初学者
C++中的函数对象（Function Object）
Michae的博客
12-31 8481
一个函数对象，即一个重载了括号操作符“（）”的对象。当用该对象调用此操作符时，其表现形式如同普通函数调用一般，因此取名叫函数对象。举个最简单的例子： [cpp] view plaincopy class FuncObjType  {  public:      void operator() ()      {          cout"Hello C++!"    } 
TurboC-C++forWindows集成实验与学习环境
12-11
TurboC-C++forWindows集成实验与学习环境
C++ stl使用之vector的基本使用和遍历
zgrjkflmkyc的专栏
07-19 3964
代码如下： #include #include using namespace std; int main() { cout << "c++ stl vector and iterator test!" << endl; cout << "increase number" << endl; vector vec; vec.push_back(1);
一些遍历对象属性的常用函数
z327171559的博客
09-07 496
话不多说，直接上代码！ 一、对象的复制 把对象 a 中的可枚举属性复制到 b 中，如果有同名属性，就将其覆盖，不处理getter和setter以及复制属性。可能有人想到直接用 = 号进行赋值，如果直接采用 b =a 的方式进行复制，会导致修改 b 的同时 a 也会改变，这里涉及到对象数据类型（也有人称之为引用数据类型或复杂数据类型）的浅拷贝问题，所以很容易产生BUG。以下代码可解决此问题： ...
C++源代码的日常日记管理系统.zip
11-06
C++是一种强大的、通用的编程语言，由Bjarne Stroustrup在C语言的基础上发展而来，它支持面向对象编程，同时具有低级内存操作的灵活性。C++被广泛应用于系统软件、游戏开发、应用软件、设备驱动等各个领域。 此项目...
个人日记管理系统C++源代码.zip
06-29
总的来说，这个个人日记管理系统结合了C++的面向对象编程、文件操作、加密技术、数据结构和算法等多个方面的知识，是一个综合性的项目，对于学习和提升C++编程能力具有很高的价值。通过分析和理解这个源代码，开发者...
C++学习日记13——递归、内联、函数重载、变量的作用域和存储类型
阿木寺的博客
11-07 1201
本文章主要是介绍递归、内联、函数重载、变量的作用域和存储类型等知识点
C++实现RSA公钥私钥加密算法
04-20
RSA算法是一种非对称加密算法，它在信息...综上所述，C++实现RSA公钥私钥加密算法涉及了大数运算、素数检测、欧拉函数、模逆运算等多个数学和密码学概念。理解并实现这一算法有助于深入理解信息安全基础和加密技术。
算法学习打卡日记
ZP_icenow的博客
01-18 1181
一来通过每日打卡的方式督促自己每天学习，二来总结一下知识点；主要面向自己，希望自己能坚持住吧，有一个好的结果 2019年1月18日打卡 编程语言推荐C++（包含C） 用scanf和printf相比cin/cout效率更高 int 的范围是±21亿，超过用long long 声明赋值后面加LL 小数全用double 小写字母比大写字母ASCII码大32 #define和c...
C++学习笔记（10）---函数对象（仿函数）、STL遍历、查找、排序、拷贝与替换、算术生成、集合算法
plain_rookie的博客
08-18 575
1 函数对象 1.1 函数对象概念 （1）重载函数调用操作符的类，其对象常称为函数对象； （2）函数对象使用重载的()时，行为类似函数调用，也叫仿函数； 本质：函数对象(仿函数)是一个类，不是一个函数； 1.2 函数对象使用 特点：（1）函数对象在使用时，可以像普通函数那样调用，可以有参数，可以有返回值； （2）函数对象超出普通函数的概念，函数对象可以有自己的状态； （3）函数对象可以作为参数传递； //-------------练习1：函数对象（仿函数）----------------
C++函数指针、函数对象与C++11 function对象对比分析
vict_wang的博客
08-11 6544
函数指针怎么声明？能用来做什么？什么时候用？ 函数指针变量名称一定要和函数名字一样吗？一个函数只能定义一个函数指针吗？ 给函数指针变量初始化，获取函数的地址时，有几种方式？可以不加取址&amp;符号吗？想要传入另外一个函数，一定要提前定义吗？ 函数对象的实质是什么？怎么理解这个东西？ 怎么调用函数对象？ 函数对象和函数指针的比较？ C...
C++ STL顺序容器详解（二）
强者之路
04-08 556
C++ STL顺序容器详解（一） [目录] 顺序容器的操作 特殊的forward_list操作 改变容器的大小 容器操作的注意点 vector增长原理 顺序容器的操作 向顺序容器添加元素 下面表格有中 插入操作会改变array的大小，所以都不支持 forwar_list有自己的insert和emplace forward_list不支持push_back和emplace_back vector与...
C++ STL中sort函数
weixin_43349440的博客
09-15 167
刷题中经常遇到，用于各种元素排序，可以自定义排序方式，vector、deque适用。详细讲解：https://zhuanlan.zhihu.com/p/36274119。，为避免QuickSort快排的递归调用带来过大的额外负荷，就改用。一旦分段后的数据量小于某个门槛。STL的sort算法，
CF C. Nikita and LCM
qq_74190237的博客
09-13 264
思维题.首先先对数组排序,考虑一种特殊情况,那就是如果数组最大值不能被其他数整除,这代表什么?代表其他数里面有某个质因子,最大值里面没有或者数量不管,所有最小公倍数都会大于最大值.那么其他情况的话,就可以确定所有的数都是最大数的因子,那么形成的最小公倍数也一定是最大数的因子,那么就可以枚举一下最大数的因子,就可以了.给长度为n的数组,求出最长的特殊子数组,如果子数组的最小公倍数不在原数组中,那么就是特殊的.
C++与QML的数据交互
qq_50679120的博客
09-11 520
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】【网络】【Linux系统编程】单例模式，加锁封装TCP/IP协议套接字
最新发布
2301_79796701的博客
09-16 844
给系统，表明这个套接字所期望的、还未处理的（即还在等待被接受的连接）连接请求的最大队列长度。换句话说，它告诉系统内核为这个套接字分配多大的空间来存储尚未处理的连接请求。有关套接字编程的细节和更多的系统调用课参考《UNIX环境高级编程》一书，可以在如下网站搜索电子版，该书在第16章详细的介绍了各种接口。我们可以根据自己的需求，用面向对象的思想封装出接口简洁的类。在类似添加一个该类类型的指针，该指针是静态的并且是私有成员。结构体填充，为了使不同的地址格式能和套接字绑定，需要把对应的结构体强转成通用地址结构。
C++ STL算法详解：函数对象适配器与示例
"C++常用STL算法的学习资料，包括函数对象适配器、bind1st、bind2nd等常见算法的使用示例" 在C++编程中，STL（Standard Template Library，标准模板库）提供了丰富的算法和容器，极大地提高了代码的可复用性和效率...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值