一文详解C++仿函数

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

//定义一个仿函数用来比较两个整数
struct CompareInt{
    bool operator()(int a,int b) const{
        return a<b;
    }
};

int main()
{
    vector<int> numbers={5,2,9,1,5,6};

    //使用STL中的sort算法和自定义的仿函数对vector进行排序
    std::sort(numbers.begin(),numbers.end(),CompareInt());

    //输出排序后的vector
    for(int num:numbers)
    {
        cout<<num<<" ";
    }
    cout<<endl;

    return 0;
}

#include <iostream>
using namespace std;

//定义一个仿函数类，带有内部状态
class Accumulator{
    //构造函数，初始化内部状态
public:
    Accumulator(int initial_sum=0) : internal_sum(initial_sum) {}
    //重载operator(),使其接受一个整数参数，将其与内部状态相加，并返回结果
    int operator()(int value){
        internal_sum+=value; //修改内部状态
        return internal_sum; //返回累加后的结果
    }
    //获取当前内部状态
    int get_sum() const {
        return internal_sum;
    }
private:
    int internal_sum;//仿函数的内部状态
};

int main()
{
    //创建Accumulator类的实例，初始化内部状态为0
    Accumulator accumulator;

    //使用仿函数来调用它，即使用它跟使用一个函数一样
    cout<<"After adding 5:"<<accumulator(5)<<endl;
    cout<<"After adding 3:"<<accumulator(3)<<endl;
    cout<<"Current sum:"<<accumulator.get_sum()<<endl;

    //创建另一个Accumulator实例，初始化内部状态为10
    Accumulator accumulator2(10);

    //使用这个实例进行累加
    cout<<"initial sum 10,after adding 2:"<<accumulator2(2)<<endl;



    return 0;
}

#include <iostream>

// 定义一个仿函数类
class MyFunctor {
public:
    // 重载 operator()
    int operator()(int value) const {
        return value * 2;
    }
};

// 定义一个接受仿函数作为参数的函数
void applyFunctor(const MyFunctor& functor, int value)
{
    std::cout << "经过仿函数处理过后的值: " << functor(value) << std::endl;
}

int main() {
    // 创建仿函数实例
    MyFunctor functor;
    // 调用接受仿函数为参数的函数
    applyFunctor(functor, 5);

    return 0;
}

#include <iostream>
#include <vector>
#include <algorithm>

// 定义一个仿函数类，用于将整数乘以2
class MultiplyByTwo {
public:
    // 重载 operator()，实现对传入整数的乘以2操作
    int operator()(int value) const {
        return value * 2;
    }
};

// 定义一个接受仿函数作为模板参数的函数模板
// 该函数模板用于对 vector 中的每个元素应用仿函数进行变换
template <typename Functor>
void transformVector(std::vector<int> &vec, Functor functor) {
    // 遍历 vector 中的每个元素，并应用仿函数进行变换
    for (auto &item : vec) {
        item = functor(item);
    }
}

int main() {
    // 初始化一个包含整数的 vector
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用 MultiplyByTwo 仿函数类作为模板参数，调用 transformVector 函数
    // 对 vector 中的每个元素进行乘以2的操作
    transformVector(vec, MultiplyByTwo());

    // 输出变换后的 vector 元素
    for (auto item : vec) {
        std::cout << item << " ";
    }
    std::cout << std::endl;

    //也可以直接使用lambda表达式作为模板参数
    transformVector(vec,[](int value){return value*3;});
    //再次输出变换后的值
    for (auto item : vec) {
        std::cout << item << " ";
    }
    std::cout << std::endl;

    return 0;
}

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

// 定义一元谓词函数，检查整数是否为偶数
// 参数：
// - num: 需要检查的整数
// 返回值：
// - 如果 num 是偶数，返回 true；否则返回 false
bool isEven(int num) {
    return num % 2 == 0;
}

int main() {
    // 初始化一个包含整数的 vector
    vector<int> vec{1, 2, 3, 4, 5, 6, 7, 8, 9};

    // 使用 std::remove_if 和一元谓词 isEven 移除所有偶数
    // std::remove_if 将所有满足条件（即偶数）的元素移动到 vector 的末尾，并返回新末尾的迭代器
    // vec.erase 则删除从新末尾到原末尾的所有元素，从而实现移除操作
    vec.erase(remove_if(vec.begin(), vec.end(), isEven), vec.end());

    // 输出处理之后的 vector 元素
    for (auto i : vec) {
        cout << i << " ";
    }
    cout << endl;

    return 0;
}

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

// 定义二元谓词函数，用于比较两个整数的大小（降序排序）
// 参数：
// - a: 第一个整数
// - b: 第二个整数
// 返回值：
// - 如果 a 大于 b，返回 true；否则返回 false
bool CompareInt(int a, int b) {
    return a > b;
}

int main() {
    // 初始化一个包含整数的 vector
    vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5};

    // 使用 std::sort 和二元谓词 CompareInt 对 vector 进行降序排序
    // std::sort 接受三个参数：起始迭代器、结束迭代器和比较函数
    // 比较函数 CompareInt 确定了排序顺序为降序
    std::sort(vec.begin(), vec.end(), CompareInt);

    // 输出处理之后的 vector 元素
    for (auto i : vec) {
        cout << i << " ";
    }
    cout << endl;

    return 0;
}