我认为计算一个数的模是一种比较费时的操作，至少相对于简单的算术测试（例如查看一个数字是否超过了数组的长度）。如果确实如此，那么将以下代码替换为更高效的代码是否更好：
res = array[(i + 1) % len];
有以下的内容是什么？：
res = array[(i + 1 == len) ? 0 : i + 1];
第一个代码段看起来更加舒适，但我想知道第二个是否更高效。如果是这样的话，当使用编译性语言时，我是否可以期望优化编译器将第一个片段替换为第二个呢？
当然，这种“优化”（如果它确实是一种优化）并不适用于所有情况（在这种情况下，仅当 i+1 不超过 len 时才有效）。
int foo = 54321; int bar = foo / 10000; foo -= bar * 10000; 来获得模数，而一个优秀的编译器甚至可以优化该代码。 - autistic一些简单的测量：
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int test = atoi(argv[1]);
int divisor = atoi(argv[2]);
int iterations = atoi(argv[3]);
int a = 0;
if (test == 0) {
for (int i = 0; i < iterations; i++)
a = (a + 1) % divisor;
} else if (test == 1) {
for (int i = 0; i < iterations; i++)
a = a + 1 == divisor ? 0 : a + 1;
}
printf("%d\n", a);
}
使用gcc或clang编译时加上-O3选项，然后运行time ./a.out 0 42 1000000000（模数版本）或者time ./a.out 1 42 1000000000（比较版本），结果如下：
（使用gcc 5.2.1或clang 3.6.2；Intel Core i5-4690K @ 3.50GHz；64-bit Linux）
这意味着最好使用比较版本。
好的，以下是获取“模3”循环计数器下一个值的两种方法。
int next1(int n) {
return (n + 1) % 3;
}
int next2(int n) {
return n == 2 ? 0 : n + 1;
}
addl $1, %edi
movl $1431655766, %edx
movl %edi, %eax
imull %edx
movl %edi, %eax
sarl $31, %eax
subl %eax, %edx
leal (%rdx,%rdx,2), %eax
subl %eax, %edi
movl %edi, %eax
ret
而第一个函数的长度（我敢打赌速度也会更慢）比第二个函数长得多：
leal 1(%rdi), %eax
cmpl $2, %edi
movl $0, %edx
cmove %edx, %eax
ret
因此，“现代编译器总是比你更好”并不总是正确的。
有趣的是，使用4而不是3进行相同的实验会导致第一个函数的与掩码。
addl $1, %edi
movl %edi, %edx
sarl $31, %edx
shrl $30, %edx
leal (%rdi,%rdx), %eax
andl $3, %eax
subl %edx, %eax
ret
但是它仍然相对于第二版而言，大体上来说，较为低劣。
更明确地介绍正确方法来做事。
int next3(int n) {
return (n + 1) & 3;;
}
leal 1(%rdi), %eax
andl $3, %eax
ret
(*) 嗯，不是很复杂。倒数乘法。计算整数常量 K = (2^N)/3，对于足够大的 N 值。现在，当您想要 X/3 的值时，不要进行除以 3 的运算，而是计算 X*K，并将其向右移动 N 个位置。
% 4 代码更复杂，因为你正在进行 有符号 算术运算。根据 C99 的规定，模数的符号必须与被除数的符号相匹配，因此它不仅仅是一个直接的按位 AND。将类型更改为 unsigned int，您将获得与 & 3 代码相同的结果。 - pat#include <stdio.h>
#include <stdlib.h>
#define modulo
int main()
{
int iterations = 1000000000;
int size = 16;
int a[size];
unsigned long long res = 0;
int i, j;
for (i=0;i<size;i++)
a[i] = i;
for (i=0,j=0;i<iterations;i++)
{
j++;
#ifdef modulo
j %= size;
#else
if (j >= size)
j = 0;
#endif
res += a[j];
}
printf("%llu\n", res);
}
大小=15：
大小=16：
使用gcc 7.3.0编译，采用-O3优化。 计算机配置为i7 920。
这里有一些额外的基准测试。请注意，我还添加了一个无分支版本:
#include <iostream>
#include <array>
#include <algorithm>
#include <random>
#include <chrono>
using namespace std::chrono;
constexpr size_t iter = 1e8;
int main() {
std::minstd_rand rnd_engine{1234};
std::uniform_int_distribution<int> dist {-1000, 1000};
auto gen = [&]() { return dist(rnd_engine); };
std::array<int, 10> a;
std::generate( a.begin(), a.end(), gen);
for (size_t size = 2; size < 10; size++) {
std::cout << "Modulus size = " << size << '\n';
{
std::cout << "operator% ";
long sum = 0;
size_t x = 0;
auto start = high_resolution_clock::now();
for (size_t i = 0; i < iter; ++i) {
sum += a[x];
x = (x + 1) % size;
}
auto stop = high_resolution_clock::now();
std::cout << duration_cast<microseconds>(stop - start).count()*0.001
<< "ms\t(sum = " << sum << ")\n";
}
{
std::cout << "ternary ";
long sum = 0;
size_t x = 0;
auto start = high_resolution_clock::now();
for (size_t i = 0; i < iter; ++i) {
sum += a[x];
x = ((x + 1) == size) ? 0 : x + 1;
}
auto stop = high_resolution_clock::now();
std::cout << duration_cast<microseconds>(stop - start).count()*0.001
<< "ms\t(sum = " << sum << ")\n";
}
{
std::cout << "branchless ";
long sum = 0;
size_t x = 1;
auto start = high_resolution_clock::now();
for (size_t i = 0; i < iter; ++i) {
sum += a[x-1];
x = ( x != size ) * x + 1;
}
auto stop = high_resolution_clock::now();
std::cout << duration_cast<microseconds>(stop - start).count()*0.001
<< "ms\t(sum = " << sum << ")\n";
}
}
return 0;
}
这是在我的i7-4870HQ上的输出结果
$ g++ -Ofast test.cpp && ./a.out
Modulus size = 2
operator% 904.249ms (sum = -4200000000)
ternary 137.04ms (sum = -4200000000)
branchless 169.182ms (sum = -4200000000)
Modulus size = 3
operator% 914.911ms (sum = -31533333963)
ternary 113.384ms (sum = -31533333963)
branchless 167.614ms (sum = -31533333963)
Modulus size = 4
operator% 877.3ms (sum = -36250000000)
ternary 97.265ms (sum = -36250000000)
branchless 167.215ms (sum = -36250000000)
Modulus size = 5
operator% 891.295ms (sum = -30700000000)
ternary 88.562ms (sum = -30700000000)
branchless 167.087ms (sum = -30700000000)
Modulus size = 6
operator% 903.644ms (sum = -39683333196)
ternary 83.433ms (sum = -39683333196)
branchless 167.778ms (sum = -39683333196)
Modulus size = 7
operator% 908.096ms (sum = -34585713678)
ternary 79.703ms (sum = -34585713678)
branchless 166.849ms (sum = -34585713678)
Modulus size = 8
operator% 869ms (sum = -39212500000)
ternary 76.972ms (sum = -39212500000)
branchless 167.29ms (sum = -39212500000)
Modulus size = 9
operator% 875.003ms (sum = -36500000580)
ternary 75.011ms (sum = -36500000580)
branchless 172.356ms (sum = -36500000580)
operator%将是简单明了的，而另外两种方法可能会变得非常复杂。例如，通过删除对如果len是编译时常量，最近的GCC编译器（使用-02）通常会做一些聪明的事情，经常避免目标处理器的模数机器指令。 - Basile Starynkevitch
size变量的循环并将其声明为const size_t size = 4;，我得到：g++ -Ofast test.cpp && ./a.out
Modulus size = 4
operator% 62.103ms (sum = -36250000000)
ternary 93.674ms (sum = -36250000000)
branchless 166.774ms (sum = -36250000000)
无分支版本的执行时间在不同场景下非常稳定。三元操作符相对于无分支版本在考虑的情况下始终更好，特别是当分支预测器发挥作用时。最后，operator%虽然更加通用但明显较慢，它有可能在右侧特定的常量值的情况下得到优化并成为最快的。
当然，这完全取决于平台，谁知道在Arduino上会是什么情况 :)
取模运算符虽然昂贵，但除法也很昂贵。因此，将代码从使用取模运算符转换为除法不会优化您的代码。
(i + 1) % len
为了优化上述代码
if ((i+1)==len){
return 0
} else {
return i+1
}
我读了一篇关于制作快速哈希表的文章。瓶颈可能是模数运算符来查找哈希桶。他们建议将您的桶数量设为2的幂次方。显然，通过2的幂次方进行模数运算就像只查看最后n位一样。
%会明显变慢。如果你只调用几次，我不会担心这个问题。if (value % alignment != 0)语句的CPU使用率高达10%，这是相当大的开销。但由于我的对齐方式总是2的幂，我能够通过使用简单的位运算符&进行优化。if ((value & (alignment - 1)) != 0)
在大多数体系结构上（例如x86上的DIV），模运算可以使用单个处理器指令完成。但是，这可能是对您所需的过早优化。
div 是目前最慢的整数 ALU 操作。例如，在 Skylake 上，div r64 的延迟时间为 35 至 90 个周期，而 imul r64, r64 的延迟时间仅为 3 个周期。相关链接：C++ code for testing the Collatz conjecture faster than hand-written assembly - why? 展示了 div 有多么慢，特别是与移位操作相比，后者可以用于计算2的幂。 - Peter Cordes
len是一个编译时常数，最近版本的 GCC 编译器（使用-O2选项）通常会进行聪明的优化，往往可以避免目标处理器的取模指令。 - Basile Starynkevitch