使用 .size() 与 const 变量进行循环
Using .size() vs const variable for loops
我有一个 vector:
vector<Body*> Bodies;
它包含指向我定义的 Body 个对象的指针。
我还有一个 unsigned int const，其中包含我希望在 bodies 中拥有的 body 个对象的数量。
unsigned int const NumParticles = 1000;
我已经用 NumParticles 个 Body 个对象填充了 Bodies。
现在，如果我想遍历一个循环，例如在 Bodies 中调用每个 Body 的 Update() 函数，我有两个选择：
第一个：
for (unsigned int i = 0; i < NumParticles; i++)
{
Bodies.at(i)->Update();
}
或第二个：
for (unsigned int i = 0; i < Bodies.size(); i++)
{
Bodies.at(i)->Update();
}
各有利弊。我想知道在安全性、可读性和约定方面哪一个（如果有的话）是更好的做法。
我建议您使用 .size() 函数而不是定义新常量。
为什么？
安全：因为.size()不会抛出任何异常，所以使用.size().
可读性：恕我直言，Bodies.size() 比 NumParticles.
Bodies 的大小
约定：同样根据约定，最好使用.size()，因为它是向量的属性，而不是变量NumParticles。
性能：.size()是一个常量复杂度成员函数，所以使用const int和const int之间没有显着的性能差异.size().
我会投票给 范围:
for (auto* body : Bodies)
{
body->Update();
}
我预计，鉴于编译器（至少在这种情况下）可以内联 std::vector 中的所有相关代码，它将是相同的代码 [除了 1000 在机器代码中是一个真正的常量文字, Bodies.size() 将是 "variable" 值]。
调查结果的简短摘要：
编译器不会在每次迭代时调用向量的 size() 函数，它会在循环开始时计算它，并将其用作 "constant value".
循环中的实际代码是相同的，只是循环的准备不同。
一如既往：如果性能非常重要，请使用您的数据和编译器在您的系统上进行测量。否则，编写对您的设计最有意义的代码（我更喜欢使用 for(auto i : vec)，因为它简单直接 [并且适用于所有容器]）
支持证据：
取咖啡后，我写了这段代码：
class X
{
public:
void Update() { x++; }
operator int() { return x; }
private:
int x = rand();
};
extern std::vector<X*> vec;
const size_t vec_size = 1000;
void Process1()
{
for(auto i : vec)
{
i->Update();
}
}
void Process2()
{
for(size_t i = 0; i < vec.size(); i++)
{
vec[i]->Update();
}
}
void Process3()
{
for(size_t i = 0; i < vec_size; i++)
{
vec[i]->Update();
}
}
（连同填充数组并调用 Process1()、Process2() 和 Process3() 的 main 函数 - main 位于单独的文件中以避免编译器决定内联一切，让人很难分辨什么是什么）
这是 g++ 4.9.2 生成的代码：
0000000000401940 <_Z8Process1v>:
401940: 48 8b 0d a1 18 20 00 mov 0x2018a1(%rip),%rcx # 6031e8 <vec+0x8>
401947: 48 8b 05 92 18 20 00 mov 0x201892(%rip),%rax # 6031e0 <vec>
40194e: 48 39 c1 cmp %rax,%rcx
401951: 74 14 je 401967 <_Z8Process1v+0x27>
401953: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
401958: 48 8b 10 mov (%rax),%rdx
40195b: 48 83 c0 08 add [=11=]x8,%rax
40195f: 83 02 01 addl [=11=]x1,(%rdx)
401962: 48 39 c1 cmp %rax,%rcx
401965: 75 f1 jne 401958 <_Z8Process1v+0x18>
401967: f3 c3 repz retq
0000000000401970 <_Z8Process2v>:
401970: 48 8b 35 69 18 20 00 mov 0x201869(%rip),%rsi # 6031e0 <vec>
401977: 48 8b 0d 6a 18 20 00 mov 0x20186a(%rip),%rcx # 6031e8 <vec+0x8>
40197e: 31 c0 xor %eax,%eax
401980: 48 29 f1 sub %rsi,%rcx
401983: 48 c1 f9 03 sar [=11=]x3,%rcx
401987: 48 85 c9 test %rcx,%rcx
40198a: 74 14 je 4019a0 <_Z8Process2v+0x30>
40198c: 0f 1f 40 00 nopl 0x0(%rax)
401990: 48 8b 14 c6 mov (%rsi,%rax,8),%rdx
401994: 48 83 c0 01 add [=11=]x1,%rax
401998: 83 02 01 addl [=11=]x1,(%rdx)
40199b: 48 39 c8 cmp %rcx,%rax
40199e: 75 f0 jne 401990 <_Z8Process2v+0x20>
4019a0: f3 c3 repz retq
00000000004019b0 <_Z8Process3v>:
4019b0: 48 8b 05 29 18 20 00 mov 0x201829(%rip),%rax # 6031e0 <vec>
4019b7: 48 8d 88 40 1f 00 00 lea 0x1f40(%rax),%rcx
4019be: 66 90 xchg %ax,%ax
4019c0: 48 8b 10 mov (%rax),%rdx
4019c3: 48 83 c0 08 add [=11=]x8,%rax
4019c7: 83 02 01 addl [=11=]x1,(%rdx)
4019ca: 48 39 c8 cmp %rcx,%rax
4019cd: 75 f1 jne 4019c0 <_Z8Process3v+0x10>
4019cf: f3 c3 repz retq
虽然每种情况下的汇编代码看起来都略有不同，但在实践中，我想说您很难衡量这些循环之间的差异，事实上，运行 perf 代码显示它是 "the same time for all loops" [这是在一个循环中有 100000 个元素和 100 次调用 Process1、Process2 和 Process3，否则时间由 new X 在 main]:
31.29% a.out a.out [.] Process1
31.28% a.out a.out [.] Process3
31.13% a.out a.out [.] Process2
除非您认为 1/10% 很重要 - 它可能需要一周的时间才能 运行，但这只是零点几秒 [在我的机器上是 0.163 秒]，并且可能比其他任何东西都更多的测量误差 - 更短的时间实际上是理论上应该最慢的时间，Process2，使用 vec.size()。我用更高的循环次数做了另一个 运行，现在每个循环的测量值彼此相差 0.01%——换句话说，花费的时间相同。
当然，如果你仔细看，你会发现所有三个变体的实际循环内容基本相同，除了 Process3 的前面部分更简单，因为编译器知道我们将至少做一个循环 - Process1 和 Process2 必须在第一次迭代之前检查 "is the vector empty"。这会对非常短的矢量长度产生影响。
NumParticles 不是向量的 属性。它是相对于向量的一些外部常量。我更愿意使用向量的 属性 size() 。在这种情况下，reader.
的代码更加安全和清晰
通常使用一些常数而不是 size() 意味着 reader 通常常数可以不等于 size().
因此，如果您想说 reader 您将要处理向量的所有元素，那么最好使用 size()。否则使用常量。
当然，当重音放在常量上时，这条隐式规则也有例外。在这种情况下，最好使用常量。不过要看上下文。
我更喜欢这种形式：
for (auto const& it : Bodies)
{
it->Update();
}
我有一个 vector:
vector<Body*> Bodies;
它包含指向我定义的 Body 个对象的指针。
我还有一个 unsigned int const，其中包含我希望在 bodies 中拥有的 body 个对象的数量。
unsigned int const NumParticles = 1000;
我已经用 NumParticles 个 Body 个对象填充了 Bodies。
现在，如果我想遍历一个循环，例如在 Bodies 中调用每个 Body 的 Update() 函数，我有两个选择：
第一个：
for (unsigned int i = 0; i < NumParticles; i++)
{
Bodies.at(i)->Update();
}
或第二个：
for (unsigned int i = 0; i < Bodies.size(); i++)
{
Bodies.at(i)->Update();
}
各有利弊。我想知道在安全性、可读性和约定方面哪一个（如果有的话）是更好的做法。
我建议您使用 .size() 函数而不是定义新常量。
为什么？
安全：因为
.size()不会抛出任何异常，所以使用.size(). 是绝对安全的
可读性：恕我直言，
Bodies.size()比NumParticles. 更清楚地传达了矢量 约定：同样根据约定，最好使用
.size()，因为它是向量的属性，而不是变量NumParticles。性能：
.size()是一个常量复杂度成员函数，所以使用const int和const int之间没有显着的性能差异.size().
Bodies 的大小
我会投票给 范围:
for (auto* body : Bodies)
{
body->Update();
}
我预计，鉴于编译器（至少在这种情况下）可以内联 std::vector 中的所有相关代码，它将是相同的代码 [除了 1000 在机器代码中是一个真正的常量文字, Bodies.size() 将是 "variable" 值]。
调查结果的简短摘要：
编译器不会在每次迭代时调用向量的
size()函数，它会在循环开始时计算它，并将其用作 "constant value".循环中的实际代码是相同的，只是循环的准备不同。
一如既往：如果性能非常重要，请使用您的数据和编译器在您的系统上进行测量。否则，编写对您的设计最有意义的代码（我更喜欢使用
for(auto i : vec)，因为它简单直接 [并且适用于所有容器]）
支持证据：
取咖啡后，我写了这段代码：
class X
{
public:
void Update() { x++; }
operator int() { return x; }
private:
int x = rand();
};
extern std::vector<X*> vec;
const size_t vec_size = 1000;
void Process1()
{
for(auto i : vec)
{
i->Update();
}
}
void Process2()
{
for(size_t i = 0; i < vec.size(); i++)
{
vec[i]->Update();
}
}
void Process3()
{
for(size_t i = 0; i < vec_size; i++)
{
vec[i]->Update();
}
}
（连同填充数组并调用 Process1()、Process2() 和 Process3() 的 main 函数 - main 位于单独的文件中以避免编译器决定内联一切，让人很难分辨什么是什么）
这是 g++ 4.9.2 生成的代码：
0000000000401940 <_Z8Process1v>:
401940: 48 8b 0d a1 18 20 00 mov 0x2018a1(%rip),%rcx # 6031e8 <vec+0x8>
401947: 48 8b 05 92 18 20 00 mov 0x201892(%rip),%rax # 6031e0 <vec>
40194e: 48 39 c1 cmp %rax,%rcx
401951: 74 14 je 401967 <_Z8Process1v+0x27>
401953: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
401958: 48 8b 10 mov (%rax),%rdx
40195b: 48 83 c0 08 add [=11=]x8,%rax
40195f: 83 02 01 addl [=11=]x1,(%rdx)
401962: 48 39 c1 cmp %rax,%rcx
401965: 75 f1 jne 401958 <_Z8Process1v+0x18>
401967: f3 c3 repz retq
0000000000401970 <_Z8Process2v>:
401970: 48 8b 35 69 18 20 00 mov 0x201869(%rip),%rsi # 6031e0 <vec>
401977: 48 8b 0d 6a 18 20 00 mov 0x20186a(%rip),%rcx # 6031e8 <vec+0x8>
40197e: 31 c0 xor %eax,%eax
401980: 48 29 f1 sub %rsi,%rcx
401983: 48 c1 f9 03 sar [=11=]x3,%rcx
401987: 48 85 c9 test %rcx,%rcx
40198a: 74 14 je 4019a0 <_Z8Process2v+0x30>
40198c: 0f 1f 40 00 nopl 0x0(%rax)
401990: 48 8b 14 c6 mov (%rsi,%rax,8),%rdx
401994: 48 83 c0 01 add [=11=]x1,%rax
401998: 83 02 01 addl [=11=]x1,(%rdx)
40199b: 48 39 c8 cmp %rcx,%rax
40199e: 75 f0 jne 401990 <_Z8Process2v+0x20>
4019a0: f3 c3 repz retq
00000000004019b0 <_Z8Process3v>:
4019b0: 48 8b 05 29 18 20 00 mov 0x201829(%rip),%rax # 6031e0 <vec>
4019b7: 48 8d 88 40 1f 00 00 lea 0x1f40(%rax),%rcx
4019be: 66 90 xchg %ax,%ax
4019c0: 48 8b 10 mov (%rax),%rdx
4019c3: 48 83 c0 08 add [=11=]x8,%rax
4019c7: 83 02 01 addl [=11=]x1,(%rdx)
4019ca: 48 39 c8 cmp %rcx,%rax
4019cd: 75 f1 jne 4019c0 <_Z8Process3v+0x10>
4019cf: f3 c3 repz retq
虽然每种情况下的汇编代码看起来都略有不同，但在实践中，我想说您很难衡量这些循环之间的差异，事实上，运行 perf 代码显示它是 "the same time for all loops" [这是在一个循环中有 100000 个元素和 100 次调用 Process1、Process2 和 Process3，否则时间由 new X 在 main]:
31.29% a.out a.out [.] Process1
31.28% a.out a.out [.] Process3
31.13% a.out a.out [.] Process2
除非您认为 1/10% 很重要 - 它可能需要一周的时间才能 运行，但这只是零点几秒 [在我的机器上是 0.163 秒]，并且可能比其他任何东西都更多的测量误差 - 更短的时间实际上是理论上应该最慢的时间，Process2，使用 vec.size()。我用更高的循环次数做了另一个 运行，现在每个循环的测量值彼此相差 0.01%——换句话说，花费的时间相同。
当然，如果你仔细看，你会发现所有三个变体的实际循环内容基本相同，除了 Process3 的前面部分更简单，因为编译器知道我们将至少做一个循环 - Process1 和 Process2 必须在第一次迭代之前检查 "is the vector empty"。这会对非常短的矢量长度产生影响。
NumParticles 不是向量的 属性。它是相对于向量的一些外部常量。我更愿意使用向量的 属性 size() 。在这种情况下，reader.
通常使用一些常数而不是 size() 意味着 reader 通常常数可以不等于 size().
因此，如果您想说 reader 您将要处理向量的所有元素，那么最好使用 size()。否则使用常量。
当然，当重音放在常量上时，这条隐式规则也有例外。在这种情况下，最好使用常量。不过要看上下文。
我更喜欢这种形式：
for (auto const& it : Bodies)
{
it->Update();
}