CentOS C++函数指针如何运用 - 问答

在C++中，函数指针是一种特殊的指针，它存储了一个函数的地址。在CentOS或其他Linux系统上使用C++时，函数指针可以用于多种目的，例如回调函数、实现策略模式、动态调用等。下面是一些使用函数指针的基本示例：

定义和初始化函数指针：

#include <iostream>

// 定义一个简单的函数
int add(int a, int b) {
    return a + b;
}

int main() {
    // 定义一个函数指针，并将其指向add函数的地址
    int (*funcPtr)(int, int) = &add;

    // 使用函数指针调用函数
    int result = funcPtr(3, 4);
    std::cout << "Result: " << result << std::endl; // 输出 "Result: 7"

    return 0;
}

使用函数指针作为回调：

#include <iostream>
#include <functional>

// 定义一个接受函数指针作为参数的函数
void process(int value, std::function<int(int, int)> func) {
    int result = func(value, value);
    std::cout << "Processed value: " << result << std::endl;
}

// 定义一个简单的函数
int multiply(int a, int b) {
    return a * b;
}

int main() {
    // 使用函数指针作为回调传递给process函数
    process(5, multiply); // 输出 "Processed value: 25"

    return 0;
}

使用函数指针实现策略模式：

#include <iostream>
#include <vector>
#include <memory>

// 定义一个策略接口
class Strategy {
public:
    virtual ~Strategy() {}
    virtual int execute(int a, int b) = 0;
};

// 定义一个具体的策略
class AddStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a + b;
    }
};

// 定义另一个具体的策略
class MultiplyStrategy : public Strategy {
public:
    int execute(int a, int b) override {
        return a * b;
    }
};

// 定义一个上下文类，它使用策略
class Context {
private:
    std::unique_ptr<Strategy> strategy;

public:
    Context(std::unique_ptr<Strategy> strat) : strategy(std::move(strat)) {}

    int executeStrategy(int a, int b) {
        return strategy->execute(a, b);
    }
};

int main() {
    // 创建一个AddStrategy实例
    auto addStrategy = std::make_unique<AddStrategy>();

    // 创建一个Context实例，并将AddStrategy传递给它
    Context context(std::move(addStrategy));

    // 使用Context执行策略
    int result = context.executeStrategy(3, 4);
    std::cout << "Result: " << result << std::endl; // 输出 "Result: 7"

    return 0;
}

在CentOS上编译C++代码时，通常使用g++编译器。例如，如果你有一个名为example.cpp的源文件，你可以使用以下命令编译它：

g++ -o example example.cpp

然后运行生成的可执行文件：

./example

请注意，C++11引入了std::function和lambda表达式，这些特性使得函数指针的使用更加灵活和安全。在实际编程中，你可能会更多地使用std::function而不是原始的函数指针。

0 赞

0 踩