C ++应该重载函数还是如果语句就足够了？

Question

大家下午好。

我有一个关于 C++ 中的函数重载的问题。

类中有一个非常大的函数，我的任务是使其更易于阅读并降低其复杂性。

在该函数中，几乎存在两个相似的代码块。唯一的区别在于一些参数和一些额外的行。

我想从这些块中创建一个函数以避免重复，但是怎么做更好呢？我应该重载那个新函数还是在函数内添加一个 if 语句，以便如果一个参数具有这个或那个值，那么这几行额外的行也应该执行？

最好的方法是什么？

函数长这样

void f1(){
  //some code 
  {
  //some code block
  //some other line that belongs to this block
  //the code block continues
  }
  {
  //the same kind of code block
  //this line is completely different
  //the code block continues
  }

  //some code
}

所以，我想用代码块制作一个函数，但它们并不完全相同，需要在中间执行一些不同的操作。 示例：

void boo(){
  //code block
  //if(blah) execute this additional line
  //else this line
  //code block
}

或重载

void boo(param1, param2){
   //code block
   //unique line
   //code block
}
 void boo(param1, param2, param3){
   //code block
   //unique line
   //code block
}

Answer 1

你可以改变

void boo(param1, param2){
    //code block
    //unique line
    //code block
}
void boo(param1, param2, param3){
    //code block
    //unique line
    //code block
}

进入

void baa() {
    // code block1
}

void bee() {
    // code block2
}

void boo(param1, param2){
    baa();
    //unique line
    bee();
}
void boo(param1, param2, param3){
    baa();
    //unique line
    bee();
}

或者，您可以为唯一行传入一个 lambda 函数：

void boo(std::function<int()> unique) {
    // code block
    int bleh = unique();
    // code block
}

然后这样调用：

boo([]() { return 1; });
boo([]() { return 3; });

Answer 2

所以，据我了解，你的情况是这样的：

int FirstFunction(int parameter_1, bool parameter_2) {
  // first large section of code shared by both
  // line unique to FirstFunction
  // second large section of code shared by both
}

int SecondFunction(long parameter_1, Dawg parameter_2) {
  // line unique to SecondFunction
  // first large section of code shared by both
  // second large section of code shared by both
}

这是准确的吗？如果是这样，我只需取出两个函数之间相同（或非常相似）的每一段代码，将该部分放入它自己的函数中，然后从两者中调用它。重复直到没有重复代码：

void FirstSharedCode(/* parameters */) {
  // first large section of code shared by both
}

void SecondSharedCode(/* parameters */) {
  // second large section of code shared by both
}

int FirstFunction(int parameter_1, bool parameter_2) {
  FirstSharedCode(/* parameters */);
  // line unique to FirstFunction
  SecondSharedCode(/* parameters */);
}

int SecondFunction(long parameter_1, Dawg parameter_2) {
  // line unique to SecondFunction
  FirstSharedCode(/* parameters */);
  SecondSharedCode(/* parameters */);
}

Answer 3

从问题陈述来看，最初的复杂函数如下所示：

void f1(){
  //some code 
  {
     { <common_code_block_0> }
     <unique_code>
     { <common_code_block_1> }
  }
  {
     { <common_code_block_0> }
     <unique_code>
     { <common_code_block_1> }
  }

  //some code
}

有两个重复的公共代码块。这些需要被隔离以降低复杂性和未来错误的可能性。只需将它们中的每一个放在一个单独的函数中：

void function_0
{
   { <common_code_block_0> }
} 

void function_1
{
   { <common_code_block_1> }
} 

进一步将这两个函数声明为内联函数，以避免函数调用产生任何开销。

 inline  void function_0();    
 inline  void function_1();

由于在每个分支上的两个 common_code 块之间执行了一些独特的代码，因此可能有参数要传入/返回到这些新函数/从这些新函数中传递。所以它们可能看起来像：

//parameters are I/O
inline void function_0(data_type* param1, data_type* param2, etc);
inline void function_1(data_type* param1, data_type* param2, etc);

最初的 f1() 现在看起来像：

  void f1(){
  //some code 
  {
     function_0(&param1, &param2, etc);
     <unique_code>
     function_1(&param3, &param4, etc);
  }
  {
     function_0(&param1, &param2, etc);
     <unique_code>
     function_1(&param3, &param4, etc);
  }

  //some code
}