#include <iostream>
using namespace std;

class MyFunctor {                     // 定义一个“仿函数”类
public:
    // 重载 operator()，让它能像函数一样被调用
    void operator()(int x) {
        cout << "调用了函数对象，参数是：" << x << endl;
    }
};

int main() {
    MyFunctor obj;                     // 创建一个对象
    obj(42);                           // 像函数一样调用它！
    // 输出：调用了函数对象，参数是：42
    return 0;
}

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

class Accumulator {
private:
    int sum;                          // 用来保存累加结果
public:
    Accumulator() : sum(0) {}         // 初始化为0
    
    void operator()(int value) {
        sum += value;                 // 每次被调用，把 value 加到 sum 上
    }
    
    int getSum() const { return sum; }
};

int main() {
    vector<int> nums = {1, 2, 3, 4, 5};
    Accumulator acc;                  // 创建累加器对象，sum=0
    
    for_each(nums.begin(), nums.end(), acc);  // 传入 acc
    
    cout << "总和是：" << acc.getSum() << endl;  // 输出什么？是0！错了！
    return 0;
}

Accumulator result = for_each(nums.begin(), nums.end(), Accumulator());
cout << "总和是：" << result.getSum() << endl;  // 输出 15

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

struct GreaterThanTwo {               // 判断是否大于2
    bool operator()(int x) const {
        return x > 2;
    }
};

int main() {
    vector<int> v = {1, 2, 3, 4, 5};
    auto it = find_if(v.begin(), v.end(), GreaterThanTwo());  // 查找第一个大于2的元素
    if (it != v.end()) {
        cout << "第一个大于2的元素是：" << *it << endl;       // 输出 3
    }
    return 0;
}

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

struct Descending {                   // 降序比较器
    bool operator()(int a, int b) const {
        return a > b;                 // 如果 a > b，说明 a 应该排在 b 前面
    }
};

int main() {
    vector<int> nums = {5, 3, 8, 1, 9};
    sort(nums.begin(), nums.end(), Descending());
    for (int x : nums) {
        cout << x << " ";             // 输出 9 8 5 3 1
    }
    return 0;
}

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

struct Adder {                        // 把两个数相加
    int operator()(int a, int b) const {
        return a + b;
    }
};

int main() {
    vector<int> a = {1, 2, 3};
    vector<int> b = {10, 20, 30};
    vector<int> result(a.size());
    
    transform(a.begin(), a.end(), b.begin(), result.begin(), Adder());
    // result 变成 {11, 22, 33}
    for (int x : result) {
        cout << x << " ";
    }
    return 0;
}

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

// 1. 无状态的函数对象：仅仅打印元素，不需要记住任何东西
struct Printer {
    void operator()(int x) const {    // const 表示这个操作不会修改对象内部状态
        cout << x << " ";
    }
};

// 2. 有状态的函数对象：计算平均值，需要记住 sum 和 count
class AverageCalculator {
private:
    double sum;                       // 所有值的总和
    int count;                        // 一共处理了多少个元素
public:
    AverageCalculator() : sum(0), count(0) {}
    
    void operator()(int value) {
        sum += value;                 // 累加
        ++count;                      // 计数
    }
    
    double getAverage() const {
        return (count == 0) ? 0.0 : sum / count;
    }
};

// 3. 用作二元谓词的函数对象：降序比较
struct DescendingCompare {
    bool operator()(int a, int b) const {
        return a > b;                 // 如果 a > b，则 a 排在 b 前面（降序）
    }
};

int main() {
    vector<int> nums = {5, 3, 8, 1, 9};
    
    // 测试无状态的 Printer
    cout << "原始数组：";
    for_each(nums.begin(), nums.end(), Printer());
    cout << endl;
    
    // 测试有状态的 AverageCalculator
    AverageCalculator result = for_each(nums.begin(), nums.end(), AverageCalculator());
    cout << "平均值：" << result.getAverage() << endl;
    
    // 测试降序排序
    sort(nums.begin(), nums.end(), DescendingCompare());
    cout << "降序排列后：";
    for_each(nums.begin(), nums.end(), Printer());
    cout << endl;
    
    return 0;
}

原始数组：5 3 8 1 9 
平均值：5.2
降序排列后：9 8 5 3 1 

from typing import List

# 1. 无状态的打印类
class Printer:
    def __call__(self, x):          # 让对象可调用
        print(x, end=' ')

# 2. 有状态的平均值计算器
class AverageCalculator:
    def __init__(self):
        self.sum = 0.0              # 总和
        self.count = 0              # 个数
    
    def __call__(self, value):
        self.sum += value           # 累加
        self.count += 1             # 计数
    
    def get_average(self):
        return self.sum / self.count if self.count != 0 else 0.0

# 3. 降序比较函数对象（Python 中通常用 lambda，这里演示类）
# 注意：Python 的 sort 不接受二元比较谓词，需要用 cmp_to_key 转换
from functools import cmp_to_key

class DescendingCompare:
    def __call__(self, a, b):
        # 返回负数表示 a<b，正数表示 a>b，0 表示相等
        return -1 if a > b else 1 if a < b else 0

def main():
    nums = [5, 3, 8, 1, 9]
    
    # 无状态打印
    print("原始数组：", end='')
    for x in nums:
        Printer()(x)                 # 也可以先创建对象再调用
    print()
    
    # 有状态平均值
    avg_calc = AverageCalculator()
    for x in nums:
        avg_calc(x)                  # 手动遍历每个元素
    print("平均值：", avg_calc.get_average())
    
    # 降序排序（使用 cmp_to_key）
    sorted_nums = sorted(nums, key=cmp_to_key(DescendingCompare()))
    print("降序排列后：", end='')
    for x in sorted_nums:
        print(x, end=' ')
    print()
    
    # 更简单的做法：直接设置 reverse=True
    nums.sort(reverse=True)
    print("降序排列后（简单方法）：", end='')
    for x in nums:
        print(x, end=' ')
    print()

if __name__ == "__main__":
    main()