C++如何通过指定接口调用函数并实现可替换后置处理逻辑

问题1：实现fun1/fun2接口调用指定函数 #

先假设你原有的f1、f2函数签名和基础逻辑如下（如果实际签名不同，调整函数指针类型即可）：

#include <string>

enum class Mode { Direct, Inverse };

// 原f1函数
void f1(Mode mode, int b) {
    std::string s = "base";
    s.append(std::to_string(b));
    // 其他原有逻辑
}

// 原f2函数
void f2(Mode mode, int b) {
    std::string s = "base";
    s.insert(0, std::to_string(b));
    // 其他原有逻辑
}

如果想用函数指针实现接口，步骤如下：

1. 定义匹配f1/f2签名的函数指针类型：

using FuncPtr = void(*)(Mode, int);

2. 实现fun1和fun2，直接通过函数指针调用目标函数：

void fun1(int b) {
    FuncPtr target = &f1;
    target(Mode::Direct, b);
}

void fun2(int b) {
    FuncPtr target = &f2;
    target(Mode::Inverse, b);
}

如果逻辑简单，也可以直接调用，无需函数指针变量：

void fun1(int b) { f1(Mode::Direct, b); }
void fun2(int b) { f2(Mode::Inverse, b); }

问题2：合并为通用函数f，切换字符串处理逻辑 #

核心是把字符串的差异化处理逻辑抽离，作为参数或分支条件传入通用函数，以下是三种常用实现方式：

方式1：函数指针传递处理逻辑 #

适合需要复用处理逻辑的场景：

// 定义字符串处理函数的签名
using StringProcessor = void(*)(std::string&, int);

// 实现两种处理逻辑
void appendHandler(std::string& s, int val) {
    s.append(std::to_string(val));
}

void insertHandler(std::string& s, int val) {
    s.insert(0, std::to_string(val));
}

// 通用函数f
void f(StringProcessor handler, int b) {
    std::string s = "base";
    handler(s, b); // 执行差异化逻辑
    // 公共逻辑（比如打印、存储等）
}

// 实现接口
void fun1(int b) { f(appendHandler, b); }
void fun2(int b) { f(insertHandler, b); }

方式2：Lambda表达式（C++11+） #

无需单独定义处理函数，代码更紧凑：

#include <functional> // 引入std::function

void f(const std::function<void(std::string&, int)>& handler, int b) {
    std::string s = "base";
    handler(s, b);
    // 公共逻辑
}

void fun1(int b) {
    f([](std::string& s, int val) { s.append(std::to_string(val)); }, b);
}

void fun2(int b) {
    f([](std::string& s, int val) { s.insert(0, std::to_string(val)); }, b);
}

方式3：枚举分支判断 #

适合逻辑简单、分支较少的场景，直观易懂：

enum class ProcessType { Append, Insert };

void f(ProcessType type, int b) {
    std::string s = "base";
    switch(type) {
        case ProcessType::Append:
            s.append(std::to_string(b));
            break;
        case ProcessType::Insert:
            s.insert(0, std::to_string(b));
            break;
        default:
            // 处理无效类型
            break;
    }
    // 公共逻辑
}

void fun1(int b) { f(ProcessType::Append, b); }
void fun2(int b) { f(ProcessType::Insert, b); }

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