论函数对象
1.引出问题
函数对象说白了就是类似于C语言中的函数指针，看下面的代码
我们知道调用一个函数的话，可以用C代码来实现
int sum(int a, int b)
{
return a + b;
}
int ret = sum(2, 1);
当然也可以这样用C++来实现
像这个operator重载了两个参数，叫做二元，重载一个叫做一元
class Sum
{
public:
int operator(int a, int b)
{
return a + b;
}
};
Sum sum;
int ret = sum(2, 1);
其中这个sum就叫做函数对象
把有operator()运算符重载函数的对象，称为函数对象或者称为仿函数
其中无论这个类或者结构体里是否还有其他的函数，但只要看有没有operator()运算符重载函数就行
函数对象一般来说只包含一个operator()运算符重载函数，但也可以包括其他的函数
在上面代码里
//int operator(int a, int b)
sum(2, 1) 等同于 sum.operator()(2, 1);
那既然他们两个都能实现，那用函数对象有啥好处吗
2.函数对象的好处
再看下面的例子
template<typename T>
bool compare(T a, T b)
{
return a > b;
}
int main()
{
cout << compare(10, 20) << endl;
cout << compare('b', 'y') << endl;
return 0;
}
现在如果想调用compare实现小于的话，会想，那把里面的a > b改成a < b不就好了，但万一情况是这个函数的实现是在库里怎么办，你总不能去改人家库里的东西吧，不现实
有人也会说，那我再实现一个这个不就好了
template<typename T>
bool compare(T a, T b)
{
return a < b;
}
那如果多了的话，你还一个个实现吗，也没啥必要
C语言的函数指针就可以解决这个问题
template<typename T>
bool greater(T a, T b)
{
return a > b;
}
template<typename T>
bool less(T a, T b)
{
return a < b;
}
// compare是C++的库函数模板
template<typename T>
bool compare(T a, T b)
{
return a > b;
}
int main()
{
cout << compare(10, 20) << endl;
cout << compare('b', 'y') << endl;
return 0;
}
因为compare是C++的库函数模板，所以他不能在函数里面写死，写成要么大于，要么小于的，所以应该再传入个参数，去接收个函数指针Compare
template<typename T, typenmae Compare>
bool compare(T a, T b, Compare comp)
{
return comp(a, b);//把ab当做这两个函数的参数传进来，根据传入的函数comp它的返回值我们再进行返回
}
这时候代码应该这样子
template<typename T>
bool mygreater(T a, T b)
{
return a > b;
}
template<typename T>
bool myless(T a, T b)
{
return a < b;
}
// compare是C++的库函数模板
template<typename T>
bool compare(T a, T b, Compare comp)
{
return comp(a, b);
}
int main()
{
cout << compare(10, 20, mygreater<int>) << endl;
cout << compare('b', 'y', myless<int>) << endl;
return 0;
}
compare(10, 20, greater<int>)
这个代码进去后首先进入compare函数里，用return comp(a, b)，也就是return greater(10, 20)，间接调用了greater函数
compare(T a, T b, Compare comp)，第三个参数传入了greater的函数地址，也就是函数指针
但return comp(a, b) 通过函数指针调用函数，是没有办法内联的，效率很低，因为有函数的调用开销
因为内联是发生在编译阶段的，比如
inline void func() {}
template<typename T>
bool compare(T a, T b, Compare comp)
{
func()
return comp(a, b);
}
那函数在编译时候，走到func()时，就会自动找到inline void func() {}，然后把这个函数展开，这样就省去了函数的调用开销了
但就算我们把刚才的代码改成这样的
template<typename T>
inline bool mygreater(T a, T b)
{
return a > b;
}
template<typename T>
inline bool myless(T a, T b)
{
return a < b;
}
// compare是C++的库函数模板
template<typename T>
bool compare(T a, T b, Compare comp)
{
return comp(a, b);
}
即使两个函数都加上inline，但编译时候走到return comp(a, b);时，编译器是不知道我调用的是 myless还是mygreater，完全不知道，除非我们明确写是调用了谁，只有在运行时候才会跑到这个地址上去找到对应的,因为函数指针只存储了函数地址，而没有任何函数体的信息
所以通过函数指针调用函数，是没有办法内联的，效率很低，因为有函数的调用开销
那我们再来看看C++函数对象的版本实现
template<typename T>
class mygreater
{
public:
bool operator()(T a, T b)
{
return a > b;
}
};
template<typename T>
class myless
{
public:
bool operator()(T a, T b)
{
return a < b;
}
};
// typename指向谁，谁就是类型名，比如这里的Compare就是一个类型
template<typename T, typename Compare>
bool compare(T a, T b, Compare comp)
{
return comp(a, b);
}
int main()
{
cout << compare(10, 20, mygreater<int>()) << endl;
cout << compare('b', 'y', myless<int>()) << endl;
}
//mygreater<int>是个类名，加个括号mygreater<int>()就是函数对象，因为是operator()重载
编译时在这里我们第一次调用compare函数的时候我们已经知道了他是调用哪个对象，比如compare(10, 20, mygreater<int>())是mygreater<int>,所以 comp 的类型就是 mygreater<int>。在第二次调用 compare 函数时，Compare 被指定为 myless<int> 类型，所以 comp 的类型就是 myless<int>。因此，在编译时，编译器就能确定 comp(a, b) 调用的是哪个函数对象，它可以在编译阶段将这个函数的函数体直接插入到调用它的地方。这个过程类似于内联函数的处理方式。
总的来说，就是函数对象相对于函数指针的一个优点是，它可以在编译时确定类型，这使得编译器能够更好地优化代码。由于函数对象是一个类，它可以重载 () 运算符，使得它可以像调用函数一样被调用。当我们通过函数对象调用一个函数时，编译器能够确定这个函数对象的类型，因此也能够确定它调用的是哪个函数。这样，编译器就可以将这个函数的函数体直接插入到调用它的地方，从而减少函数调用的开销。
3.修改其他的代码印证
再举个例子
#include <iostream>
#include <queue>
#include <set>
using namespace std;
int main()
{
priority_queue<int> que1; //vector 底层是大根堆
for(int i = 0; i < 10; i++)
{
que1.push(rand() % 100);
}
while(!que1.empty())
{
cout << que1.top() << " ";
que1.pop();
}
cout << endl;
}
这输出是从大到小的，那我们怎么从小到大呢，查看priority_queue源码我们会发现，第三个参数是默认less，我们是可以改的
如果我们改第三个的话，前两个参数也得手动写上
#include <iostream>
#include <queue>
#include <set>
#include <vector>
using namespace std;
int main()
{
using MinHeap = priority_queue<int, vectpr<int>, greater<int>>; //小根堆
MinHeap que2;
for(int i = 0; i < 10; i++)
{
que2.push(rand() % 100);
}
while(!que2.empty())
{
cout << que2.top() << " ";
que2.pop();
}
cout << endl;
}
这样就是按从小到大排序了
同理set也可以这样玩
- 点赞
- 收藏
- 关注作者
评论（0）