C++图搜索函数中，如何为作为参数的函数指针传递次级参数

问题背景 #

你现在实现的BFS/DFS函数只能接收void (*func)(node*)类型的函数指针，但像SetColor、SetNumber这类处理逻辑需要额外参数，直接传函数指针的话只能硬编码参数值，没法灵活传入不同参数。比如你之前的代码：

void BreadthFirstSearch(node* n, void (*func)(node*)){
     // 搜索逻辑
     func(current_node);
}
void SetColor(node* n, color c){ /* 设置颜色 */ }

// 这里根本没法传颜色参数
BreadthFirstSearch(n, SetColor, /* 颜色放哪？ */);

简化后的硬编码版本：

void BFS(node* n, void (*func)(node*)){
    std::set<node*> visited = std::set<node*>();
    std::queue<node*> frontier = std::queue<node*>();
    frontier.push(n);

    while(!frontier.empty()){
        node* current = frontier.front();
        frontier.pop();
        visited.insert(current);
        // 处理邻居...
        
        func(current);
    }
}

void set_color(node* n){
    // 只能硬编码红色
    n->color = (255, 0, 0);
}

int main(){
    BFS(start_node, set_color);
}

解决方案 #

推荐用以下几种类型安全的方式，比可变参数靠谱多了：

1. 用std::function结合Lambda表达式（最灵活）

先把BFS的参数改成std::function<void(node*)>，这样就能接收Lambda、绑定后的函数等各种可调用对象：

#include <functional>
#include <set>
#include <queue>
#include <vector>

// 先定义node结构体示例
struct node {
    int color[3];
    std::vector<node*> neighbors;
};

void BFS(node* start, std::function<void(node*)> process) {
    std::set<node*> visited;
    std::queue<node*> frontier;
    frontier.push(start);
    visited.insert(start); // 提前标记已访问，避免重复入队

    while (!frontier.empty()) {
        node* current = frontier.front();
        frontier.pop();

        // 执行自定义处理逻辑
        process(current);

        // 遍历邻居节点
        for (node* neighbor : current->neighbors) {
            if (visited.find(neighbor) == visited.end()) {
                visited.insert(neighbor);
                frontier.push(neighbor);
            }
        }
    }
}

然后在main里用Lambda捕获你需要的额外参数，直接传给BFS：

// 带参数的处理函数
void SetColor(node* n, const int c[3]) {
    n->color[0] = c[0];
    n->color[1] = c[1];
    n->color[2] = c[2];
}

void SetNumber(node* n, int num) {
    // 假设node有number成员
    // n->number = num;
}

int main() {
    // 构建你的图，这里示例生成一个起始节点
    node* start_node = new node();

    // 传入红色参数处理节点
    int red[3] = {255, 0, 0};
    BFS(start_node, [red](node* n) {
        SetColor(n, red);
    });

    // 传入数字42处理节点
    BFS(start_node, [](node* n) {
        SetNumber(n, 42);
    });

    return 0;
}

2. 用函数对象（仿函数）

自定义一个结构体，把额外参数存在成员里，重载operator()来处理节点：

struct ColorSetter {
    int color[3];
    // 构造函数传入颜色参数
    ColorSetter(const int c[3]) {
        color[0] = c[0];
        color[1] = c[1];
        color[2] = c[2];
    }

    // 重载()运算符，接收node*
    void operator()(node* n) {
        n->color[0] = color[0];
        n->color[1] = color[1];
        n->color[2] = color[2];
    }
};

// 也可以把BFS写成模板函数，更高效（避免std::function的开销）
template<typename Func>
void BFS_Template(node* start, Func process) {
    std::set<node*> visited;
    std::queue<node*> frontier;
    frontier.push(start);
    visited.insert(start);

    while (!frontier.empty()) {
        node* current = frontier.front();
        frontier.pop();
        process(current);

        for (node* neighbor : current->neighbors) {
            if (!visited.count(neighbor)) {
                visited.insert(neighbor);
                frontier.push(neighbor);
            }
        }
    }
}

// 使用示例
int main() {
    node* start_node = new node();
    int blue[3] = {0, 0, 255};
    // 直接传ColorSetter对象，自动调用operator()
    BFS_Template(start_node, ColorSetter(blue));
    return 0;
}

3. 用std::bind绑定已有函数参数

如果已经写好带参数的处理函数，用std::bind把额外参数绑定进去，生成适配node*的可调用对象：

#include <functional>

// BFS用std::function参数（同方法1）
void BFS(node* start, std::function<void(node*)> process) {
    // 实现同方法1
}

// 带三个颜色参数的处理函数
void SetColor(node* n, int r, int g, int b) {
    n->color[0] = r;
    n->color[1] = g;
    n->color[2] = b;
}

int main() {
    node* start_node = new node();
    // 绑定红色参数，std::placeholders::_1表示留空的node*参数
    auto set_red = std::bind(SetColor, std::placeholders::_1, 255, 0, 0);
    BFS(start_node, set_red);
    return 0;
}

为什么不推荐可变参数？ #

可变参数（va_list）类型不安全，你得手动判断参数类型和个数，很容易出bug，而且代码可读性差。上面的方法都是类型安全的，编译器会帮你检查错误，用起来也更灵活。

内容的提问来源于stack exchange，提问作者NAMEGOESHERE