C++ C+；中的内置mod运算符与算术while循环+；

我对编程比较陌生，在研究了关于这个主题的一些问题之后，我仍然找不到答案

<> P>正如我所理解的，C++中的>%/De>>运算符可以用多种方式重写，其中一些似乎在这里的一些用户表示得更好：

现在如果我理解正确的话，整数上的算术运算，比如

+

和

-

比

*

和

/

要快，比如当我们把乘法看作重复加法时（这在我读过的线程中经常提到）

那么，为什么像下面这样的函数不能比

%

更快呢

int mod(int a, int b)
{
   int s = a;

   while(s < b)
   {
     s += a;
   }
   return a - (s - b);
}

intmod（inta，intb）
{
int s=a；
而（s

---

由于我对编程非常陌生，对编译器如何实现几乎一无所知，因此我不确定采用何种方法来测试这一点，以及结果是否会因编译器和实现的不同而有很大差异。

Moulo通常通过一个或几个CPU操作来实现，所以一般来说，这是一个单一的操作：不计算辅助指令

但根据定义，它应该非常简单：

int mult = a / b; 
return a - mult * b;

例如，在x86-64 clang编译上

int mod(int a, int b)
{
   return a % b;
}

在下面的代码中，实际操作是整数除法

您的版本：

mod(int, int):                               # @mod(int, int)
        push    rbp
        mov     rbp, rsp
        mov     dword ptr [rbp - 4], edi
        mov     dword ptr [rbp - 8], esi
        mov     eax, dword ptr [rbp - 4]
        mov     dword ptr [rbp - 12], eax
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
        mov     eax, dword ptr [rbp - 12]
        cmp     eax, dword ptr [rbp - 8]
        jge     .LBB0_3
        mov     eax, dword ptr [rbp - 4]
        add     eax, dword ptr [rbp - 12]
        mov     dword ptr [rbp - 12], eax
        jmp     .LBB0_1
.LBB0_3:
        mov     eax, dword ptr [rbp - 4]
        mov     ecx, dword ptr [rbp - 12]
        sub     ecx, dword ptr [rbp - 8]
        sub     eax, ecx
        pop     rbp
        ret

---

这是在循环中执行的相当多的操作，它是否能更快是值得怀疑的/

Moulo通常通过一个或几个CPU操作来实现，所以通常它是单一操作：不计算辅助指令

但根据定义，它应该非常简单：

int mult = a / b; 
return a - mult * b;

例如，在x86-64 clang编译上

int mod(int a, int b)
{
   return a % b;
}

在下面的代码中，实际操作是整数除法

您的版本：

mod(int, int):                               # @mod(int, int)
        push    rbp
        mov     rbp, rsp
        mov     dword ptr [rbp - 4], edi
        mov     dword ptr [rbp - 8], esi
        mov     eax, dword ptr [rbp - 4]
        mov     dword ptr [rbp - 12], eax
.LBB0_1:                                # =>This Inner Loop Header: Depth=1
        mov     eax, dword ptr [rbp - 12]
        cmp     eax, dword ptr [rbp - 8]
        jge     .LBB0_3
        mov     eax, dword ptr [rbp - 4]
        add     eax, dword ptr [rbp - 12]
        mov     dword ptr [rbp - 12], eax
        jmp     .LBB0_1
.LBB0_3:
        mov     eax, dword ptr [rbp - 4]
        mov     ecx, dword ptr [rbp - 12]
        sub     ecx, dword ptr [rbp - 8]
        sub     eax, ecx
        pop     rbp
        ret

---

这是循环中执行的相当多的操作，它是否能更快是值得怀疑的/

“当我们把乘法看作是重复加法时”——然而，这不是任何只用纸笔进行乘法的人的想法。你的CPU也没有。至于你的问题：测试它：创建一个简单的程序，对这两个变量（使用你的函数和

%

操作符）分别执行一百万次。在启用优化的情况下构建它。然后计算每个变量的时间。这将告诉您如何使用编译器在您的平台上执行每项操作。您还可以比较两种变体生成的机器代码（例如，使用“非常适用于此”）。但是请记住，对于任何类型的基准测试，总是在启用优化的情况下构建。“当我们将乘法视为重复加法时”-然而，这并不是任何只使用纸笔进行乘法的人的想法。你的CPU也没有。至于你的问题：测试它：创建一个简单的程序，对这两个变量（使用你的函数和

%

操作符）分别执行一百万次。在启用优化的情况下构建它。然后计算每个变量的时间。这将告诉您如何使用编译器在您的平台上执行每项操作。您还可以比较两种变体生成的机器代码（例如，使用“非常适用于此”）。但是请记住，对于任何类型的基准测试，构建时都要启用优化。这不仅仅是操作的数量。分支和

jmp.LBB0_1

是破坏者。@TedLyngmo当然，尽管有些CPU架构比其他的要好，但这不仅仅是操作量的问题。分支和

jmp.LBB0_1

是破坏者。@TedLyngmo当然，尽管有些CPU架构比其他的要好