如何正确分解代码？

Question

我有一个非常基本的编程问题。想象一下，我有两个函数，它们的定义实际上是相同的，只是它们仅在内部二进制条件下有所不同。这两个函数中的其余代码实际上是相同的。

为了有一个可读且易于维护的代码，我想知道除了使用布尔参数来选择这些函数的操作模式是否有更好的解决方案？有没有design-pattern 呢？

在下面的代码中，我用两个名为doA() 和doB() 的函数来说明我的疑问。点 (....) 对应于两个函数完全相同的代码。 我创建了一个新的doNew() 函数，并带有一个额外的布尔参数来选择适当的功能。但是，请注意，尽管这是一种可能的解决方案，但由于 if 两个条件的正文中存在重复代码，它仍然效率低下。

void doA( ..... ){
     .....
     .....
         if(x!=y){
             ....
             ....
             ....
         }
     .....
}

void doB( ..... ){
     .....
     .....
         if(x==y){
             ....
             ....
             ....
         }
     .....
}

void doNew( ....., bool selectionMode ){
     .....
     .....
         if(selectionMode == true){
             if(x==y){
                 ....
                 ....
                 ....
             }
         }
         else{
             if(x!=y){
                 ....
                 ....
                 ....
             }

         }
     .....
}

Answer 1

我还会使用一个布尔参数来区分它们。对于这么简单的过程，我不会使用复杂的模式。

我会用

void doIt(..., BOOL is_equal) {
   ...
   if((a == b) == is_equal) { // or: is_equal ^ (a == b)
      ...
   }
   ...
}

最终减少冗余。我也会定义独立的名字

void doA(...) {
    doIt(..., true);
}

void doB(...) {
    doIt(..., false);
}

因为我认为 API 中的标志参数不好。

Answer 2

许多人建议使用函子，这是个好建议。对您来说最棒的是 == 和 != 的仿函数等价物以及其他此类比较运算符已经作为标准 C++ 库的一部分存在。这是我的做法：

#include <functional>
#include <iostream>

template <class T, template <class T> class BinaryFunctor>
void doSomething(T x, T y, BinaryFunctor<T> f) {
  if (f(x, y)) {
    std::cout << "True" << std::endl;
  } else {
    std::cout << "False" << std::endl;
  }
}

int main(int argc, const char* argv[])
{
  doSomething(5, 5, std::equal_to<int>());
  return 0;
}

doSomething 模板函数接受两个相同类型的参数 T 和一个类型为 BinaryFunctor<T> 的参数。请注意，T 出现在所有三个参数中，因此在传递的所有参数中必须相同。所以传递两个ints 和一个std::equal_to<int> 很好（就像我在示例中所做的那样），因为T 可以实例化为int 和BinaryFunctor 到std::equal_to。

std::equal_to 是标准库的比较函数对象（或函子）之一的示例。它只是一个覆盖operator() 的类，因此std::equal_to 类型的对象可以像真正的函数一样使用。因此，当std::equal_to 类型的对象作为f 参数传递给函数时，您可以像f(someInt, anotherInt) 一样使用它。

现在，如果您想将比较运算符更改为!=，只需将函数调用更改为doSomething(5, 5, std::not_equal_to<int>());，它就会按预期工作。您还可以找到其他仿函数，例如（省略 std 命名空间）：greater、less、greater_equal、less_equal 等。

Answer 3

您不需要模式，您需要重构技术。

我倾向于写四个函数让你得到

DoA()
{
   Part1();
   SpecificForA();
   Part2();
};

DoB()
{
   Part1();
   SpecificForB();
   Part2();
};

您可能需要在它们之间共享一些变量作为参数。这些函数可能是有用的、可重用的函数。更有可能的是，您会发现需要进行更多重构。现在这更容易了，因为在提取这些函数后，您更清楚它们的作用。

Answer 4

你可以这样写：

if(selectionMode && x==y || !selectionMode && x!=y)
    //....

还有其他方法可以做到这一点。您可以传递一个进行比较的函子（例如：一个函数指针）。您可以使用仿函数模板参数编写模板，并使用模板定义这两个函数。

更新：

人们提供了几个示例，因此我将向您展示一个不同的示例，这个示例使用普通函数指针，并且不传递两个值进行比较，而是传递比较的结果。 （注意：其他例子是首选，但你看到的例子越多越好）

//type of the function pointer
typedef bool (*dofuncptr)(bool);

bool do_istrue(bool b) {
    return b;
}

//negates the input
bool do_isfalse(bool b) {
    return b;
}

void doX(dofuncptr fun) {
    //...
    if (fun(x == y)) {
        //....
    }
    //...
}

int main() {
    //you can use it like this:
    doX(&do_istrue);
}

Answer 5

对于动态解决方案，我会使用指针函数。

void(*doNew)(...);
doNew = &doA;
doNew(...);//now calls doA
doNew = &doB;
doNew(...);//now calls doB

对于静态解决方案... 我会使用值类型模板函数。 前任。

template<bool TMode>
void doNew( .....);
template<>
void doNew<TRUE>( .....);
{
     .....
     .....
             if(x==y){
                 ....
                 ....
                 ....
             }
     .....
     .....
}
template<>
void doNew<FALSE>( .....);
{
     .....
     .....
             if(x!=y){
                 ....
                 ....
                 ....
             }
     .....
     .....
}

然后你可以像...一样使用它

doNew<FALSE>(...); // is equivalant to doNew(..., false);

Answer 6

我会说你将do 作为模板函数和二进制函数作为函数的函子参数。比如：

template <class BinaryFunctor>
void do(...,BinaryFunctor f)

这个二元仿函数将返回一个bool，您可以在do 中使用它。

仿函数示例代码：

struct Equals
{
    Equals(int x , int y) : m_x(x), m_y(y){}
    bool operator()() const { return m_x == m_y;}

private:
    int m_x;
    int m_y;
};
struct NotEquals
{
    NotEquals(int x , int y) : m_x(x), m_y(y){}
    bool operator()() const { return m_x != m_y;}

private:
    int m_x;
    int m_y;
};
template<class BinaryFunctor>
void doSomething(BinaryFunctor f)
{
    if(f())
    {
        //Condition satisfied
    }
}
int main () 
{
    doSomething(Equals(10,11));
    doSomething(NotEquals(10,11));
    return 0;
}