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

我有一个名为 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循环的每一轮都进行 if (index)检查，即使结果总是相同的。 这与“担心业绩”是背道而驰的。

我可以很容易地避免这一点，把检查外面的 for循环。 然而，我会得到大量重复的代码:

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

所以这两个对我来说都是“糟糕”的解决方案。 我一直在想的是两个私有函数其中一个超出索引然后调用另一个。 The other one only outs the value. 然而，我不知道如何使用它与我的程序，我仍然需要 if检查，看看哪一个调用..。

根据这个问题，多态似乎是一个正确的解决方案。 But I can't see how should I use it here. 解决这类问题的首选方法是什么？

这不是一个真正的程序，我只是对如何解决这类问题感兴趣。

14880 次浏览
小开

在函数中，我对 for 循环的每一轮执行 if (index)检查，即使结果始终相同。这与“担心业绩”是背道而驰的。

如果 确实如此，那么分支预测器在预测(常数)结果方面就没有问题了。因此，在最初的几个迭代中，这只会导致轻微的预测错误开销。没什么好担心的

In this case I advocate for keeping the test inside the loop for clarity.

小开
最佳答案

作为函数体传入循环体。 它在编译时内联，没有性能损失。

在 C++标准程式库中，传递不同信息的想法无处不在，这就是所谓的 策略模式。

If you are allowed to use C++11, you can do something like this:

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

同样，这个代码远远不够完美，但是它给了你一个想法。

小开

为了扩展 Ali 的答案，这是完全正确的，但仍然重复了一些代码(部分循环体，这是不幸的，很难避免使用策略模式) ..。

在这种特殊情况下，虽然代码复制不是很多，但是有一种方法可以进一步减少代码复制，这就是 如果函数体大于几个指令。

关键是使用编译器执行 常数折叠/死码删除的能力。我们可以通过手动将 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);
}

This way we end up with compiled code which is equivalent to your second code example (outer if / inner for) but without duplicating the code ourselves. Now we can make the template version of writeVector as complicated as we want, there will always be a single piece of code to maintain.

注意模板版本(采用非类型模板参数形式的编译时常量)和非模板版本(采用运行时变量作为函数参数)是如何重载的。这允许你根据自己的需要选择最相关的版本，在这两种情况下都有一个非常相似、易于记忆的语法:

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
小开

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

#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

The result assembly of write_vector is:

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>

Of course, this only works if a compiler is capable to detect that a condition is actual invariant. Usually, it perfectly works for flags and simple inline functions. But if the condition is "complex", consider using approaches from other answers.


提交答案