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

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

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 2

您可以更改

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 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
}

有两个常见的代码块重复出现。需要隔离这些以降低复杂性和未来错误的可能性。 Jut将其中的每一个放在一个单独的函数中：

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
}

C ++应该重载函数还是语句足够？

3 个答案: