避免在 for 循环中使用 if 语句？答案

【问题标题】：Avoiding if statement inside a for loop?避免在 for 循环中使用 if 语句？
【发布时间】：2013-05-28 02:41:50
【问题描述】：

我有一个名为 Writer 的类，它有一个函数 writeVector，如下所示：

void Drawer::writeVector(vector<T> vec, bool index=true)
{
    for (unsigned int i = 0; i < vec.size(); i++) {
        if (index) {
            cout << i << "\t";
        }
        cout << vec[i] << "\n";
    }
}

我正在努力避免重复代码，同时仍然担心性能。在函数中，我正在对我的for-loop 的每一轮进行if (index) 检查，即使结果始终相同。这是反对“担心性能”的。

我可以通过将检查放在我的for-loop 之外来轻松避免这种情况。但是，我会得到大量重复的代码：

void Drawer::writeVector(...)
{
    if (index) {
        for (...) {
            cout << i << "\t" << vec[i] << "\n";
        }
    }
    else {
        for (...) {
            cout << vec[i] << "\n";
        }
    }
}

所以这些对我来说都是“坏”的解决方案。我一直在想的是两个私有函数，其中一个超出索引，然后调用另一个。另一个只是超出了价值。但是，我不知道如何在我的程序中使用它，我仍然需要 if 检查以查看要调用哪个...

根据问题，多态似乎是一个正确的解决方案。但我看不出我应该如何在这里使用它。解决此类问题的首选方法是什么？

这不是一个真正的程序，我只是想了解应该如何解决这类问题。

【问题讨论】：

@JonathonReinhart 也许有些人想学习编程，对如何解决问题感到好奇？
我已经给这个问题+1了。这种优化可能并不经常需要，但首先，指出这一事实可能是答案的一部分，其次，罕见的优化类型仍然与编程高度相关。
问题是关于避免代码重复和循环内部复杂逻辑的良好设计。这是一个好问题，无需反对。
这是一个有趣的问题，通常编译器中的循环转换会非常有效地解决这个问题。如果函数像这样足够小，则内联会处理它，并且很可能会完全杀死分支。我宁愿更改代码，直到内联程序愉快地内联代码，而不是使用模板解决这个问题。
@JonathonReinhart：你们为什么不能假设 OP 已经分析了他的代码，然后回答这个该死的问题？即使OP没有，将来看到这个问题的人也可能有。用愚蠢的“你为什么在乎？” cmets 来驳回问题，你没有给任何人任何好处。

标签： c++ c++11 for-loop design-patterns

【解决方案1】：

在函数中，我对我的每一轮 for 循环进行 if (index) 检查，即使结果始终相同。这是反对“担心性能”的。

如果确实如此，则分支预测器在预测（常数）结果时将没有问题。因此，这只会导致前几次迭代中的错误预测的轻微开销。性能方面不用担心

在这种情况下，为了清晰起见，我主张将测试保留在循环中。

【讨论】：

这只是一个例子，我是来学习如何解决这种问题的。我只是好奇，甚至没有创建一个真正的程序。应该在问题中提到它。
在这种情况下，请记住过早的优化是万恶之源。编程时，始终关注代码的可读性，并确保其他人理解您正在尝试做什么。 在分析您的程序并识别热点之后，仅考虑微优化和各种 hack。在没有确定对优化的需求之前，您永远不应该考虑优化。很多时候，性能问题并不是您所期望的。
在这个特定的例子中（好吧，理解，这只是一个例子）很可能除了花费在 IO 上的时间之外，循环控制和 if 测试所花费的时间几乎是不可见的。这通常是 C++ 的一个问题：在以维护为代价的可读性和（假设的）效率之间进行选择。
您假设代码运行在具有分支预测功能的处理器上。大多数运行 C++ 的系统都没有。（虽然，可能大多数具有有用std::cout 的系统都可以）
-1。是的，分支预测在这里可以很好地工作。是的，编译器实际上可能会将条件提升到循环之外。是的，波伊特罗埃。但是循环中的分支是危险的事情，经常会影响性能，如果有人说“分支预测”，我不认为仅仅说“分支预测”是一个好建议真的很在乎性能。最值得注意的例子是向量化编译器需要predication 来处理这个问题，产生的代码效率低于无分支循环。

【解决方案2】：

将循环体作为函子传递。它在编译时被内联，没有性能损失。

传递变化的东西的想法在 C++ 标准库中无处不在。它被称为策略模式。

如果允许你使用 C++11，你可以这样做：

#include <iostream>
#include <set>
#include <vector>

template <typename Container, typename Functor, typename Index = std::size_t>
void for_each_indexed(const Container& c, Functor f, Index index = 0) {

    for (const auto& e : c)
        f(index++, e);
}

int main() {

    using namespace std;

    set<char> s{'b', 'a', 'c'};

    // indices starting at 1 instead of 0
    for_each_indexed(s, [](size_t i, char e) { cout<<i<<'\t'<<e<<'\n'; }, 1u);

    cout << "-----" << endl;

    vector<int> v{77, 88, 99};

    // without index
    for_each_indexed(v, [](size_t , int e) { cout<<e<<'\n'; });
}

这段代码并不完美，但你明白了。

在旧的 C++98 中是这样的：

#include <iostream>
#include <vector>
using namespace std;

struct with_index {
  void operator()(ostream& out, vector<int>::size_type i, int e) {
    out << i << '\t' << e << '\n';
  }
};

struct without_index {
  void operator()(ostream& out, vector<int>::size_type i, int e) {
    out << e << '\n';
  }
};


template <typename Func>
void writeVector(const vector<int>& v, Func f) {
  for (vector<int>::size_type i=0; i<v.size(); ++i) {
    f(cout, i, v[i]);
  }
}

int main() {

  vector<int> v;
  v.push_back(77);
  v.push_back(88);
  v.push_back(99);

  writeVector(v, with_index());

  cout << "-----" << endl;

  writeVector(v, without_index());

  return 0;
}

同样，代码远非完美，但它为您提供了思路。

【讨论】：

for(int i=0;i<100;i++){cout<<"Thank you!"<<endl;} :D 这是我一直在寻找的解决方案，它就像一个魅力 :) 你可以用几个 cmets 来改进它（一开始很难理解），但我得到了所以没问题:)
我很高兴它有帮助！请检查我的 C++11 代码更新，与 C++98 版本相比，它不那么臃肿。
Nitpick：这在 OP 的示例情况下很好，因为循环体很小，但如果它更大（想象十几行代码而不是单个 cout << e << "\n";）仍然会有相当多的代码重复。
为什么在 C++03 示例中使用了结构和运算符重载？为什么不只创建两个函数并将指针传递给它们呢？
@Malcolm 内联。如果它们是结构，则函数调用很可能是内联的。如果你传递一个函数指针，这些调用很可能不能被内联。

【解决方案3】：

扩展阿里的答案，这是完全正确的，但仍然重复了一些代码（循环体的一部分，不幸的是，在使用策略模式时这很难避免）......

在这种特殊情况下，代码重复并不多，但有一种方法可以进一步减少它，这会派上用场如果函数体大于几条指令。

关键是利用编译器执行不断折叠/死代码消除的能力。我们可以通过手动将 index 的运行时值映射到编译时值来做到这一点（当只有有限数量的情况时很容易做到——在这种情况下是两个）并使用非类型模板参数，即在编译时已知：

template<bool index = true>
//                  ^^^^^^ note: the default value is now part of the template version
//                         see below to understand why
void writeVector(const vector<int>& vec) {
    for (size_t i = 0; i < vec.size(); ++i) {
        if (index) { // compile-time constant: this test will always be eliminated
            cout << i << "\t"; // this will only be kept if "index" is true
        }
        cout << vec[i] << "\n";
    }
}

void writeVector(const vector<int>& vec, bool index)
//                                            ^^^^^ note: no more default value, otherwise
//                                            it would clash with the template overload
{
    if (index) // runtime decision
        writeVector<true>(vec);
        //          ^^^^ map it to a compile-time constant
    else
        writeVector<false>(vec);
}

通过这种方式，我们最终得到了与您的第二个代码示例（外部if/内部for）等效的编译代码，但我们自己不需要复制代码。现在我们可以让writeVector的模板版本变得任意复杂，总有一段代码需要维护。

注意模板版本（它采用非类型模板参数形式的编译时常量）和非模板版本（它采用运行时变量作为函数参数）是如何重载的。这使您可以根据需要选择最相关的版本，在两种情况下都具有相当相似且易于记忆的语法：

writeVector<true>(vec);   // you already know at compile-time which version you want
                          // no need to go through the non-template runtime dispatching

writeVector(vec, index);  // you don't know at compile-time what "index" will be
                          // so you have to use the non-template runtime dispatching

writeVector(vec);         // you can even use your previous syntax using a default argument
                          // it will call the template overload directly

【讨论】：

请记住，您删除重复代码的代价是使循环内部的逻辑更加复杂。我认为它既不比我为这个特别简单的例子提出的更好也不差。 无论如何+1！
我喜欢您的建议，因为它显示了另一种可能的优化。 index 很有可能从一开始就是模板常量。在这种情况下，它可以由 writeVector 的调用者替换为运行时常量，并将 writeVector 更改为某个模板。避免对原始代码进行任何进一步的更改。
@kriss：实际上我之前的解决方案已经允许，如果你直接打电话给doWriteVector，但我同意这个名字很不幸。我只是将其更改为具有两个重载的writeVector 函数（一个模板，另一个是常规函数），以便结果更加均匀。谢谢你的建议。 ;)
IMO 这是最好的答案。 +1
@Mehrdad 除了它没有回答原始问题 Avoiding if statement inside a for loop? 它确实回答了如何避免性能损失。至于“重复”，需要一个更现实的用例示例来了解如何最好地分解它。正如我之前所说，我赞成这个答案。

【解决方案4】：

在大多数情况下，您的代码已经具备良好的性能和可读性。一个好的编译器能够检测循环不变量并进行适当的优化。考虑以下与您的代码非常接近的示例：

#include <cstdio>
#include <iterator>

void write_vector(int* begin, int* end, bool print_index = false) {
    unsigned index = 0;
    for(int* it = begin; it != end; ++it) {
        if (print_index) {
            std::printf("%d: %d\n", index, *it);
        } else {
            std::printf("%d\n", *it);
        }
        ++index;
    }
}

int my_vector[] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
};


int main(int argc, char** argv) {
    write_vector(std::begin(my_vector), std::end(my_vector));
}

我正在使用下面的命令行来编译它：

g++ --version
g++ (GCC) 4.9.1
Copyright (C) 2014 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
g++ -O3 -std=c++11 main.cpp

然后，让我们转储程序集：

objdump -d a.out | c++filt > main.s

write_vector 的结果汇编是：

00000000004005c0 <write_vector(int*, int*, bool)>:
  4005c0:   48 39 f7                cmp    %rsi,%rdi
  4005c3:   41 54                   push   %r12
  4005c5:   49 89 f4                mov    %rsi,%r12
  4005c8:   55                      push   %rbp
  4005c9:   53                      push   %rbx
  4005ca:   48 89 fb                mov    %rdi,%rbx
  4005cd:   74 25                   je     4005f4 <write_vector(int*, int*, bool)+0x34>
  4005cf:   84 d2                   test   %dl,%dl
  4005d1:   74 2d                   je     400600 <write_vector(int*, int*, bool)+0x40>
  4005d3:   31 ed                   xor    %ebp,%ebp
  4005d5:   0f 1f 00                nopl   (%rax)
  4005d8:   8b 13                   mov    (%rbx),%edx
  4005da:   89 ee                   mov    %ebp,%esi
  4005dc:   31 c0                   xor    %eax,%eax
  4005de:   bf a4 06 40 00          mov    $0x4006a4,%edi
  4005e3:   48 83 c3 04             add    $0x4,%rbx
  4005e7:   83 c5 01                add    $0x1,%ebp
  4005ea:   e8 81 fe ff ff          callq  400470 <printf@plt>
  4005ef:   49 39 dc                cmp    %rbx,%r12
  4005f2:   75 e4                   jne    4005d8 <write_vector(int*, int*, bool)+0x18>
  4005f4:   5b                      pop    %rbx
  4005f5:   5d                      pop    %rbp
  4005f6:   41 5c                   pop    %r12
  4005f8:   c3                      retq   
  4005f9:   0f 1f 80 00 00 00 00    nopl   0x0(%rax)
  400600:   8b 33                   mov    (%rbx),%esi
  400602:   31 c0                   xor    %eax,%eax
  400604:   bf a8 06 40 00          mov    $0x4006a8,%edi
  400609:   48 83 c3 04             add    $0x4,%rbx
  40060d:   e8 5e fe ff ff          callq  400470 <printf@plt>
  400612:   49 39 dc                cmp    %rbx,%r12
  400615:   75 e9                   jne    400600 <write_vector(int*, int*, bool)+0x40>
  400617:   eb db                   jmp    4005f4 <write_vector(int*, int*, bool)+0x34>
  400619:   0f 1f 80 00 00 00 00    nopl   0x0(%rax)

我们可以看到，在函数的请求中，我们检查值并跳转到两个可能的循环之一：

  4005cf:   84 d2                   test   %dl,%dl
  4005d1:   74 2d                   je     400600 <write_vector(int*, int*, bool)+0x40>

当然，这仅在编译器能够检测到条件是实际不变的情况下才有效。通常，它非常适用于标志和简单的内联函数。但如果条件“复杂”，请考虑使用其他答案中的方法。

【讨论】：