C++中将类中的函数指针作为变量的例子

一个简单的例子是在一个类中定义一个函数指针变量，并在构造函数中将其初始化。如下所示：

class MyClass {
public:
    typedef int (*FuncPtr)(int); // typedef 一个返回 int 类型，参数为 int 类型的函数指针类型
    MyClass(FuncPtr ptr) : func_ptr_(ptr) {} // 构造函数
    int runFunc(int arg) { return func_ptr_(arg); } // 类方法，调用函数指针指向的函数
private:
    FuncPtr func_ptr_;
};

int plusOne(int x) { return x + 1; } // 自定义的函数，将参数加 1

int main() {
    MyClass my_class(plusOne); // 传入函数指针
    int result = my_class.runFunc(5); // 调用函数指针指向的函数
    return 0;
}

在上面的例子中，MyClass 类中定义了一个函数指针类型 FuncPtr，并在构造函数中将其初始化为传入的函数指针。类方法 runFunc 接受一个参数，调用存储在 func_ptr_ 变量中的函数指针指向的函数，并将参数传给该函数。在主函数中，我们创建了一个 MyClass 对象，传入 plusOne 函数指针，并通过 runFunc 方法调用该函数实现了将参数加 1 的功能。

相关问题

C++中将函数指针作为变量的例子

一个例子是将函数指针作为参数传递给另一个函数：

#include <stdio.h>

void print_hello() {
    printf("Hello, world!\n");
}

void call_func(void (*func)()) {
    // 调用传入的函数指针
    func();
}

int main() {
    // 声明一个函数指针变量
    void (*ptr)() = print_hello;

    // 使用函数指针变量调用函数
    ptr();

    // 将函数指针作为参数传递给另一个函数
    call_func(print_hello);

    return 0;
}

在上面的例子中，我们声明了一个名为 `ptr` 的函数指针变量，并将其初始化为指向 `print_hello()` 函数的地址。然后，我们使用函数指针变量来调用 `print_hello()` 函数。

我们还定义了一个名为 `call_func()` 的函数，该函数的参数类型为一个指向无返回值、无参数的函数的指针。在 `main()` 函数中，我们调用了 `call_func()` 函数，并将 `print_hello()` 函数的地址作为参数传递给它。在 `call_func()` 函数内部，我们调用了传入的函数指针，这就是将函数指针作为变量的另一个例子。

c++中设置类的返回函数

可以使用类的成员函数来实现返回函数，例如：

class MyClass {
public:
    int x;
    int y;
    int (*getSum) (MyClass*);

    MyClass(int a, int b) {
        x = a;
        y = b;
        getSum = &MyClass::sum;
    }

    int sum() {
        return x + y;
    }
};

int main() {
    MyClass obj(3, 4);
    int sum = obj.getSum(&obj);
    std::cout << "Sum: " << sum << std::endl;
    return 0;
}

在上面的例子中，我们定义了一个 MyClass 类，它有两个成员变量 x 和 y，以及一个成员函数 sum，用于计算 x 和 y 的和。我们还定义了一个指向 sum 函数的指针 getSum，并在构造函数中将其初始化为 sum 函数的地址。在 main 函数中，我们创建了一个 MyClass 对象 obj，并通过调用 getSum 函数指针来计算 x 和 y 的和。