C++ operator()

C++ operator()

flyfish

operator() 是C++中的一种运算符重载，称为函数调用运算符或调用运算符

仿函数 （Functors）：用来封装函数或行为，使对象可以像函数一样调用

以下是一个简单的示例，展示了如何使用 operator()：

#include <iostream>

// 定义一个类
class Functor {
public:
    // 重载函数调用运算符
    void operator()() {
        std::cout << "Functor 被调用了！" << std::endl;
    }
};

int main() {
    Functor functor; // 创建 Functor 对象
    functor(); // 调用对象，就像调用函数一样
    return 0;
}

复杂点的仿函数：定义了一个 MultiplyBy 仿函数类，它的 operator() 运算符将输入的整数乘以一个因子

使用 std::transform 算法将 vec 中的每个元素乘以 3

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

// 定义一个仿函数类
class MultiplyBy {
    int factor;
public:
    MultiplyBy(int f) : factor(f) {}

    // 重载函数调用运算符
    int operator()(int x) const {
        return x * factor;
    }
};

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // 使用仿函数将每个元素乘以 3
    std::transform(vec.begin(), vec.end(), vec.begin(), MultiplyBy(3));

    for (int val : vec) {
        std::cout << val << " ";
    }

    return 0;
}

定义了一个 Event 类，它管理一个回调函数

回调函数是一种通过函数指针或仿函数在特定事件发生时调用的函数。

当 trigger 方法被调用时，它会调用设置的回调函数。使用 Callback 仿函数作为回调函数，并在 main 函数中触发事件。

#include <iostream>
#include <functional>

// 定义一个回调管理类
class Event {
    std::function<void()> callback;
public:
    void setCallback(std::function<void()> cb) {
        callback = cb;
    }

    void trigger() {
        if (callback) {
            callback();
        }
    }
};

// 定义一个仿函数类
class Callback {
public:
    void operator()() const {
        std::cout << "回调函数被调用了！" << std::endl;
    }
};

int main() {
    Event event;
    Callback callback;

    // 设置回调函数
    event.setCallback(callback);

    // 触发事件，调用回调函数
    event.trigger();

    return 0;
}

有参数的函数调用运算符

你可以定义带参数的 operator()，如下所示：

class Adder {
    int increment;
public:
    Adder(int inc) : increment(inc) {}

    int operator()(int x) const {
        return x + increment;
    }
};

int main() {
    Adder adder(5);
    std::cout << adder(10) << std::endl; // 输出 15
    return 0;
}

多个参数的函数调用运算符

函数调用运算符 operator() 的语法要求使用一对括号。内部的参数列表括号可以包含任意数量的参数，但函数调用运算符本身只有一对外括号。

class Multiplier {
public:
    int operator()(int a, int b) const {
        return a * b;
    }
};

int main() {
    Multiplier multiplier;
    std::cout << multiplier(3, 4) << std::endl; // 输出 12
    return 0;
}

重载数组下标运算符

class Array {
    int data[10];
public:
    Array() {
        for (int i = 0; i < 10; ++i) {
            data[i] = i;
        }
    }

    int& operator[](int index) {
        return data[index];
    }
};

int main() {
    Array arr;
    arr[5] = 100; // 使用重载的数组下标运算符
    std::cout << "arr[5] = " << arr[5] << std::endl; // 输出 arr[5] = 100
    return 0;
}

算术运算符** (+, -, *, /)

class Complex {
    double real, imag;
public:
    Complex(double r, double i) : real(r), imag(i) {}
    
    // 重载加法运算符
    Complex operator+(const Complex& other) const {
        return Complex(real + other.real, imag + other.imag);
    }
    
    void print() const {
        std::cout << "(" << real << ", " << imag << "i)" << std::endl;
    }
};

int main() {
    Complex a(1.0, 2.0);
    Complex b(3.0, 4.0);
    Complex c = a + b; // 使用重载的加法运算符
    c.print(); // 输出 (4.0, 6.0i)
    return 0;
}

比较运算符** (==, !=)

class Complex {
    double real, imag;
public:
    Complex(double r, double i) : real(r), imag(i) {}
    
    // 重载等于运算符
    bool operator==(const Complex& other) const {
        return real == other.real && imag == other.imag;
    }
};

int main() {
    Complex a(1.0, 2.0);
    Complex b(1.0, 2.0);
    if (a == b) {
        std::cout << "a and b are equal" << std::endl;
    }
    return 0;
}

输入输出运算符** (<<, >>)

#include <iostream>

class Complex {
    double real, imag;
public:
    Complex(double r, double i) : real(r), imag(i) {}
    
    // 重载输出运算符
    friend std::ostream& operator<<(std::ostream& os, const Complex& c) {
        os << "(" << c.real << ", " << c.imag << "i)";
        return os;
    }
};

int main() {
    Complex a(1.0, 2.0);
    std::cout << a << std::endl; // 输出 (1.0, 2.0i)
    return 0;
}