如何简化逻辑相同但参数类型不同的多函数重复代码？

先看你给出的重复代码：

void functionA(A a){
  for(auto x: vector_of_x) {
    // duplicate code, which cannot be moved to a common function
    x.abc(a);
    // some more duplicate code, which cannot be moved to a common function
  }
}

void functionB(B b){
  for(auto x: vector_of_x) {
    // duplicate code, which cannot be moved to a common function
    x.def(b);
    // some more duplicate code, which cannot be moved to a common function
  }
}

这类框架完全一致、仅核心操作（调用不同成员函数、传入不同类型参数）不同的重复代码，最优解是把通用框架抽成独立函数，将差异化的核心操作作为参数传入，或者用模板函数封装。下面是两种最实用的方案：

方案一：用lambda封装差异化逻辑（推荐） #

把所有重复的循环、前后代码放到一个通用函数process_x里，然后在调用时用lambda把不同的核心操作（x.abc(a)/x.def(b)）传递进去：

// 通用框架函数，包含所有重复代码
template<typename Func>
void process_x(Func&& func) {
  for(auto& x : vector_of_x) {  // 用引用避免不必要的拷贝
    // duplicate code, which cannot be moved to a common function
    func(x);
    // some more duplicate code, which cannot be moved to a common function
  }
}

// 简化后的原函数
void functionA(A a) {
  process_x([a](auto& x) { x.abc(a); });
}

void functionB(B b) {
  process_x([b](auto& x) { x.def(b); });
}

这个方案的优势：

• 不需要额外的模板特化或重载，代码紧凑简洁
• 差异化逻辑直接在调用点定义，可读性强
• 灵活支持任意类型的核心操作，不限于成员函数调用

方案二：模板函数+特化（适合统一管理差异化逻辑的场景） #

如果希望把差异化的方法调用逻辑统一维护，可以用模板函数+显式特化：

// 假设vector_of_x的元素类型是X
class X;

// 模板声明
template<typename T>
void call_core_method(X& x, T arg);

// 针对A类型的特化
template<>
void call_core_method(X& x, A a) {
  x.abc(a);
}

// 针对B类型的特化
template<>
void call_core_method(X& x, B b) {
  x.def(b);
}

// 通用模板函数，包含所有重复代码
template<typename T>
void process_template(T arg) {
  for(auto& x : vector_of_x) {
    // duplicate code, which cannot be moved to a common function
    call_core_method(x, arg);
    // some more duplicate code, which cannot be moved to a common function
  }
}

// 简化后的原函数
void functionA(A a) {
  process_template(a);
}

void functionB(B b) {
  process_template(b);
}

这个方案适合需要在多个地方复用相同差异化逻辑的场景，统一维护call_core_method的特化实现即可。

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