函数对象笔记

函数对象

C++中的函数对象 就是C语言中的函数指针

函数指针

指向一个函数的指针，可以动态调用不同的函数。

#include <iostream>

// 一个普通的函数
void hello() {
    std::cout << "Hello, World!" << std::endl;
}
int add(int a, int b) {
    return a + b;
}
int main() {
    // 声明一个函数指针
    void (*func_ptr)() = hello;  // func_ptr 指向 hello 函数
    func_ptr();  // 调用 hello 函数

    // 声明一个函数指针，指向返回 int 类型的函数
    int (*add_ptr)(int, int) = add;
    std::cout << "Sum: " << add_ptr(3, 4) << std::endl;  // 调用 add 函数

    return 0;
}

函数指针的劣势

• 代码中使用C++中的模板，调用使用函数指针调用函数。

• 将函数指针传入compare时，编译器并不知道函数是什么。所以不能进行内联 ，导致会有函数的调用开销

bool mygreater(int a, int b)
{
    return a > b;
}
bool myless(int a, int b)
{
    return a < b;
}
template<typename T, typename Com>
bool compare(T a, T b, Com com)
{
    return com(a, b);
}

int main()
{
    cout << compare(1, 2, mygreater) << endl;;
    cout << compare(1, 2, myless) << endl;;
}

函数对象（仿函数）

重载了operator()的对象，可以如同函数一样被调用。

#include <iostream>

// 定义一个仿函数类
class Adder {
public：
    int operator()(int a, int b) {
        return a + b ;
    }
};

int main() {
    Adder add;  // 创建一个 Adder 对象，并初始化值为 10
    std::cout << "Sum: " << add(3, 4) << std::endl;  // 调用 operator()，输出 17 (3 + 4 + 10)

    return 0;
}

函数对象的优势

• 传入函数的是一个对象，编译器知道函数是什么，因此可以进行内联，提高函数调用效率

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;
    }
};
template<typename T, typename Com>
bool compare(T a, T b, Com com)
{
    return com(a, b);
}

int main()
{
    cout << compare(1, 2, mygreater<int>()) << endl;;
    cout << compare(1, 2, myless<int>()) << endl;;
}