C++ 中 operator() 重载与最佳实践

class adder {
public:
    int operator()(int a, int b) const {
        return a + b;
    }
};
// 调用示例
adder adder;
int result = adder(5, 3);  // 等价于 adder.operator()(5, 3)

class counter {
private:
    int count;
    int step;
public:
    counter(int initial = 0, int increment = 1) : count(initial), step(increment) {}
    // 无参数调用，返回当前值并递增
    int operator()() {
        int current = count;
        count += step;
        return current;
    }
    // 重置计数器
    void operator()(int value) {
        count = value;
    }
    // 重载带步长的调用
    int operator()(int start, int increment) {
        count = start;
        step = increment;
        return operator()();  // 调用无参版本
    }
};
// 调用示例
counter counter(0, 1);
int val1 = counter();      // 返回 0，count 变为 1
int val2 = counter();      // 返回 1，count 变为 2
counter(10);               // 重置为 10
int val3 = counter(100, 5); // 重置为 100，步长为5，返回100

class accumulator {
private:
    int sum;
public:
    accumulator(int initial = 0) : sum(initial) {}
    int operator()(int value) {
        sum += value;
        return sum;
    }
    void operator()(int value, bool reset) {
        if (reset) sum = 0;
        sum += value;
    }
};
// 调用示例
accumulator acc(0);
int result1 = acc(5);        // sum = 5
int result2 = acc(3);        // sum = 8
acc(10, true);               // 重置后累加，sum = 10

class stringlengthcomparator {
public:
    bool operator()(const std::string& a, const std::string& b) const {
        return a.length() < b.length();
    }
};
// 调用示例
std::vector<std::string> strings = {"apple", "banana", "cherry", "date"};
std::sort(strings.begin(), strings.end(), stringlengthcomparator());

class numbercomparator {
private:
    bool ascending;
public:
    numbercomparator(bool asc = true) : ascending(asc) {}
    bool operator()(int a, int b) const {
        return ascending ? a < b : a > b;
    }
};
// 调用示例
std::vector<int> numbers = {5, 2, 8, 1, 9};
std::sort(numbers.begin(), numbers.end(), numbercomparator(true));   // 升序
std::sort(numbers.begin(), numbers.end(), numbercomparator(false));  // 降序

class greaterthan {
private:
    int threshold;
public:
    greaterthan(int t) : threshold(t) {}
    bool operator()(int value) const {
        return value > threshold;
    }
};
// 调用示例
std::vector<int> numbers = {1, 5, 3, 8, 2, 9};
int count = std::count_if(numbers.begin(), numbers.end(), greaterthan(5));
// count = 2 (8, 9)

class square {
public:
    int operator()(int x) const {
        return x * x;
    }
};
class addconstant {
private:
    int constant;
public:
    addconstant(int c) : constant(c) {}
    int operator()(int x) const {
        return x + constant;
    }
};
// 调用示例
std::vector<int> input = {1, 2, 3, 4, 5};
std::vector<int> output(input.size());
// 使用 square
std::transform(input.begin(), input.end(), output.begin(), square());
// output = {1, 4, 9, 16, 25}
// 使用 addconstant
std::transform(input.begin(), input.end(), output.begin(), addconstant(10));
// output = {11, 12, 13, 14, 15}

class operationcontainer {
private:
    std::string operation;
public:
    operationcontainer(const std::string& op) : operation(op) {}
    int operator()(int a, int b) const {
        if (operation == "add") return a + b;
        if (operation == "sub") return a - b;
        if (operation == "mul") return a * b;
        if (operation == "div") return b != 0 ? a / b : 0;
        return 0;
    }
};
// 调用示例
operationcontainer addop("add");
operationcontainer mulop("mul");
int result1 = addop(5, 3);  // 返回 8
int result2 = mulop(5, 3);  // 返回 15

class filter {
private:
    std::function<bool(int)> condition;
public:
    filter(std::function<bool(int)> cond) : condition(cond) {}
    std::vector<int> operator()(const std::vector<int>& input) const {
        std::vector<int> result;
        for (int value : input) {
            if (condition(value)) {
                result.push_back(value);
            }
        }
        return result;
    }
};
// 调用示例
std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
// 过滤偶数
filter evenfilter([](int x) { return x % 2 == 0; });
auto evennumbers = evenfilter(numbers);  // {2, 4, 6, 8, 10}
// 过滤大于5的数
filter greaterfilter([](int x) { return x > 5; });
auto greaternumbers = greaterfilter(numbers);  // {6, 7, 8, 9, 10}

class closure {
private:
    int capture_value;
public:
    closure(int val) : capture_value(val) {}
    int operator()(int x) const {
        return x + capture_value;
    }
    int operator()(int x, int y) const {
        return x * y + capture_value;
    }
};
// 调用示例
closure closure(10);
int result1 = closure(5);      // 返回 15 (5 + 10)
int result2 = closure(3, 4);   // 返回 22 (3 * 4 + 10)

template<typename f, typename g>
class compose {
private:
    f f;
    g g;
public:
    compose(f f_func, g g_func) : f(f_func), g(g_func) {}
    template<typename t>
    auto operator()(t x) const -> decltype(f(g(x))) {
        return f(g(x));
    }
};
// 调用示例
auto square = [](int x) { return x * x; };
auto increment = [](int x) { return x + 1; };
compose<decltype(square), decltype(increment)> compose(square, increment);
int result = compose(5);  // 先执行 increment(5) = 6, 再执行 square(6) = 36

class statelessfunction {
public:
    // 无状态函数对象应使用 const 修饰
    int operator()(int x) const {
        return x * 2;
    }
};

class stringprocessor {
public:
    std::string operator()(const std::string& input) const {
        // 使用 const 引用避免拷贝
        return input + "_processed";
    }
};