面试题：C++函数指针回调机制在复杂架构中的优化

优化思路

使用智能指针管理函数指针：避免手动内存管理可能导致的内存泄漏问题。在C++ 11及以后，可以使用std::function和std::bind来代替原始的函数指针。std::function是一个可调用对象的包装器，它可以存储、复制和调用任何可调用对象，包括函数指针、函数对象和lambda表达式。std::bind则可以将可调用对象和其参数进行绑定，生成一个新的可调用对象。
减少不必要的间接调用：频繁的函数指针回调会带来间接调用的开销。可以通过内联函数、模板元编程等技术来减少这种开销。对于一些短小的回调函数，可以将其定义为内联函数，让编译器在调用处直接插入函数体，减少函数调用的开销。模板元编程则可以在编译期生成特定的代码，进一步优化性能。
提高可维护性：对于复杂的业务逻辑，可以将回调函数进行模块化和分层处理。将相关的回调函数封装在一个类或命名空间中，使得代码结构更加清晰。同时，为回调函数添加清晰的注释，说明其功能、参数和返回值的含义，方便后续维护和理解。
增强可扩展性：采用设计模式，如观察者模式。在这种模式下，被观察对象（主题）维护一个观察者列表，当主题状态发生变化时，通知所有观察者。这样可以方便地添加或移除观察者（回调函数），提高系统的可扩展性。

代码示例

使用std::function和std::bind

#include <iostream>
#include <functional>

// 定义回调函数类型
using Callback = std::function<void(int)>;

class MyClass {
public:
    void registerCallback(Callback cb) {
        callback = cb;
    }

    void doSomething() {
        if (callback) {
            callback(42);
        }
    }

private:
    Callback callback;
};

// 普通函数作为回调
void callbackFunction(int value) {
    std::cout << "Callback function called with value: " << value << std::endl;
}

int main() {
    MyClass obj;
    // 使用std::bind绑定普通函数
    obj.registerCallback(std::bind(callbackFunction, std::placeholders::_1));
    obj.doSomething();

    // 使用lambda表达式作为回调
    obj.registerCallback([](int value) {
        std::cout << "Lambda callback called with value: " << value << std::endl;
    });
    obj.doSomething();

    return 0;
}

内联回调函数

#include <iostream>
#include <functional>

class MyClass {
public:
    using Callback = std::function<void()>;

    void registerCallback(Callback cb) {
        callback = cb;
    }

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

private:
    Callback callback;
};

// 内联回调函数
inline void inlineCallback() {
    std::cout << "Inline callback called" << std::endl;
}

int main() {
    MyClass obj;
    obj.registerCallback(inlineCallback);
    obj.doSomething();

    return 0;
}

观察者模式示例

#include <iostream>
#include <vector>
#include <functional>

// 主题类
class Subject {
public:
    using Observer = std::function<void()>;

    void attach(Observer observer) {
        observers.push_back(observer);
    }

    void detach(Observer observer) {
        for (auto it = observers.begin(); it != observers.end(); ++it) {
            if (*it == observer) {
                observers.erase(it);
                break;
            }
        }
    }

    void notify() {
        for (const auto& observer : observers) {
            observer();
        }
    }

private:
    std::vector<Observer> observers;
};

// 观察者1
void observer1() {
    std::cout << "Observer 1 notified" << std::endl;
}

// 观察者2
void observer2() {
    std::cout << "Observer 2 notified" << std::endl;
}

int main() {
    Subject subject;
    subject.attach(observer1);
    subject.attach(observer2);

    subject.notify();

    subject.detach(observer2);
    subject.notify();

    return 0;
}

星途面试题库

面试题：C++函数指针回调机制在复杂架构中的优化

知识考点

面试题答案

优化思路

代码示例