c++ - 自修改代码 vs 编译器优化 vs 重复代码

Question

我变得有点压力，因为我无法在不妥协的情况下使我的 C++ 代码高效。我开始写一些代码，如下所示

int foo(int a, int b, int c)
{
    int result;
    bool cond1 = bar1(a, b, c);
    bool cond2 = bar2(a, b, c);
    bool cond3 = bar3(a, b, c);
    for (int i = 0; i < 10000; i++)
    {
        int start = 0;
        int end = 10000;
        if (cond1)
            start = max(start, baz1(i));
        else
            start = max(start, baz2(i));
        if (cond2)
            end = min(end, baz1(i));
        else
            end = min(end, baz2(i));
        for (int j = start; j < end; j++)
        {
            if (cond3)
                result += baz3(i, j);
            else
                result -= baz3(i, j);
        }
    }
    return result;
}   

问题是，如何优化它以便在循环的每次迭代中不检查条件“cond1、cond2、cond3”。我可以将内部循环写成

...
        if (cond3)
        for (int j = start; j < end; j++)
            result += baz3(i, j);
        else
        for (int j = start; j < end; j++)
            result -= baz3(i, j);

...

这将“cond3”的检查次数从 10000 次减少到仅 10000 次。但是仍然有 29997 次冗余检查，为了优化它，我只看到了将循环复制 2^3 = 8 次的选项。由于#loops 与#conditions 呈指数级增长，我有一些问题:

1. 我可以依靠编译器优化器来展开循环吗？
2. 反对自修改代码的论点是什么，因为在这种情况下不仅可以减小程序大小，而且代码也更易于管理。我很难相信自从 C++ 被发明以来，还没有遇到过像上面这样的问题。

Answer 1

函数指针。使用函数指针。
使用 3 个函数指针，每个条件一个。

例如:

  Function_Pointer_Type_Cond1 p_cond_1_function;
  Function_Pointer_Type_Cond2 p_cond_2_function;
  if (bar1(a, b, c))
  {
    p_cond_1_function = baz1;
  }
  else
  {
    p_cond_1_function = baz2;
  }
  if (bar2(a, b, c))
  {
    p_cond_2_function = baz1;
  }
  else
  {
    p_cond_2_function = baz2;
  }
  for (int i = 0; i < 10000; i++)
  {
    int start = 0;
    int end = 10000;
    start = max(start, (*p_cond_1_function)(i));
    end   = min(end,   (*p_cond_2_function)(i));
    // ...
  }

使用函数指针可以去除“if”语句。您可以在循环之前分配函数指针，因为函数不会在 for 循环中更改。

有关函数指针的更多信息，请在网上搜索“C++ FAQ 函数指针”或在 StackOverflow 上搜索“C++ 函数指针”。