用函数对象，函数指针，std::function,比较子，lambda进行排序,operator的用法
MT每天都教我一些不懂的东西，如下
目录
- operator重载运算符
-
- 重载()
- 重载->
- 重载类型转换函数
- 函数类对象排序
- 函数指针排序
- STD::function
-
- function实现函数指针
- 使用function
- 用function实现排序
- 比较子
- lambda表达式
operator重载运算符
operator可以重载多种运算符，比如（），[]，->
当使用operator去重载类的这些运算符后，会产生一些比较神奇的行为
在这里我会将operator和函数类对象和std::function结合使用
重载()
重载()可以让类可以像一个函数一样被调用
例子1：
#include
#include
#include
// 定义一个函数对象类
class MyComparator {
public:
// 重载函数调用运算符，使得对象可以像函数一样被调用
bool operator()(int a, int b) const {
// 定义排序规则：按照绝对值大小进行排序
return abs(a) < abs(b);
}
};
int main() {
std::vector vec = {3, -1, 5, -2, 4, -6};
// 使用函数对象类创建对象
MyComparator cmp;
// 使用 sort 函数，并将函数对象作为比较函数传递
std::sort(vec.begin(), vec.end(), cmp);
// 输出排序结果
for (int num : vec) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
例子2：
#include
using namespace std;
struct A {
void operator()() {
std::cout << "This is A Object" << std::endl;
}
};
int main(){
std::function func;
A a;
func = a;
func();
}
重载->
#include
class MySmartPointer {
public:
int* operator->() {
// 假设返回一个指向 int 类型对象的指针
return &data;
}
private:
int data = 42;
};
int main() {
MySmartPointer ptr;
std::cout << "Value: " << ptr->data << std::endl; // 通过 -> 运算符访问成员
return 0;
}
重载类型转换函数
使用operator重载float()这个函数，注意不能有返回值，不能有参数
operator Type()
class MyType {
char sz[64] = { 0 };
public:
MyType() {
}
MyType(float v) {
sprintf(sz, "%f", v);
}
operator float() const {
float r;
sscanf(sz, "%f", &r);
return r;
}
};
int main()
{
MyType a = 3.6f;
float b = a + 7.9f;
}
函数类对象排序
函数类对象就是用 operator重载了 （）的类，这样的类可以像函数一样被调用
#include
#include
#include
// 定义一个函数类对象作为比较函数
class MyCompare {
public:
bool operator()(int a, int b) const {
return a < b; // 自定义排序规则：按照从小到大的顺序排序
}
};
int main() {
std::vector nums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
// 使用函数类对象进行排序（按照从小到大的顺序排序）
MyCompare compare;
std::sort(nums.begin(), nums.end(), compare);
// 输出排序结果
for (int num : nums) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
函数指针排序
平时写的最多的排序应该就是函数指针排序
bool cmp(int a,int b){
return a函数指针
例子：
typedef bool (*Compare) (int,int)；
这样以后就可以使用Compare类型去表示一个 指向返回值为bool，参数为(int,int)的一个函数的指针，相当于给 bool (int,int)函数指针起了一个别名
使用函数指针进行泛型的排序：
因为sort函数是非常灵活的，它的第三个参数，可以是函数指针，函数对象，lamdba表达式，函数指针和成员函数指针的组合等
#include
#include
#include
// 定义一个比较函数类型
typedef bool (*CompareFunction)(int, int);
// 比较函数：按照从小到大的顺序排序
bool ascendingCompare(int a, int b) {
return a < b;
}
// 比较函数：按照从大到小的顺序排序
bool descendingCompare(int a, int b) {
return a > b;
}
// 泛型排序函数，接受一个比较函数指针作为参数
void genericSort(std::vector& nums, CompareFunction compare) {
std::sort(nums.begin(), nums.end(), compare);
}
int main() {
std::vector nums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
// 使用函数指针进行泛型排序（按照从小到大的顺序排序）
genericSort(nums, ascendingCompare);
// 输出排序结果
for (int num : nums) {
std::cout << num << " ";
}
std::cout << std::endl;
// 使用函数指针进行泛型排序（按照从大到小的顺序排序）
genericSort(nums, descendingCompare);
// 输出排序结果
for (int num : nums) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}
STD::function
function实现函数指针
void print1(){
std::cout << "hello, print1" << std::endl;
}
void print2(){
std::cout << "hello, print2" << std::endl;
}
int main(int argc, char *argv[])
{
std::function func(&print1);
func();
func = &print2;
func();
return 0;
}
使用function
std::function f; // 这里表示function的对象f的参数是int，返回值是void
#include
#include
struct Foo {
Foo(int num) : num_(num) {}
void print_add(int i) const { std::cout << num_ + i << '\n'; }
int num_;
};
void print_num(int i) { std::cout << i << '\n'; }
struct PrintNum {
void operator()(int i) const { std::cout << i << '\n'; }
};
int main() {
// 存储自由函数
std::function f_display = print_num;
f_display(-9);
// 存储 lambda
std::function f_display_42 = []() { print_num(42); };
f_display_42();
// 存储到 std::bind 调用的结果
std::function f_display_31337 = std::bind(print_num, 31337);
f_display_31337();
// 存储到成员函数的调用
std::function f_add_display = &Foo::print_add;
const Foo foo(314159);
f_add_display(foo, 1);
f_add_display(314159, 1);
// 存储到数据成员访问器的调用
std::function f_num = &Foo::num_;
std::cout << "num_: " << f_num(foo) << '\n';
// 存储到成员函数及对象的调用
using std::placeholders::_1;
std::function f_add_display2 = std::bind(&Foo::print_add, foo, _1);
f_add_display2(2);
// 存储到成员函数和对象指针的调用
std::function f_add_display3 = std::bind(&Foo::print_add, &foo, _1);
f_add_display3(3);
// 存储到函数对象的调用
std::function f_display_obj = PrintNum();
f_display_obj(18);
}
用function实现排序
function可以存函数指针和lamdba表达式等：
bool cmp(int a,int b)
{
return abs(a) func =cmp;
sort(vector.begin(),vector.end(),func);
比较子
bool cmp1(int a, int b) {
return a > b;
}
//lamdba表达式
auto cmp2 = [](int a, int b) {
return a > b;
};
lambda表达式
这个lambda表达式，在实际的比较环节是比较复杂的，在这里因为我的比较规则很简单，所以看起来很简单，lambda表达式建议还是需要深入看一下，这是个难点
#include
#include
#include
int main() {
std::vector nums = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3};
// 使用 lambda 表达式作为比较函数（按照从小到大的顺序排序）
std::sort(nums.begin(), nums.end(), [](int a, int b) {
return a < b;
});
// 输出排序结果
for (int num : nums) {
std::cout << num << " ";
}
std::cout << std::endl;
return 0;
}