C++验证奇偶性时求余运算%和位运算&的速度比较

假设验证数 m 的奇偶性：

1. 一般会想到直接用求余运算，即 m % 2；
2. 用位运算也可以达到一样的效果，即 m & 1；式子就是求二进制末尾的数是 0 还是 1；

二者的运算都是奇数返回1，偶数返回0；但是最近遇到一道题，在验证的时候二者的运行速度差距比较大

（先说结果：位运算  优于 求余运算），针对这个问题，我进行了测试，代码如下：

测试编译器：QT Creator自带编译器

#include <iostream>
using namespace std;
#include <time.h>

//分别进行了 求余-位运算-求余-位运算 4次计算;
//每次用了100万个数，返回两次求余数和两次位运算的平均值;
pair<double,double> testMod(){
    double t_mod1,t_mod2,t_bit1,t_bit2;
    //01模块:求余
    clock_t start = clock();
    //测试块-----------
    int arr1[500000];
    for(int i = 0; i < 1000000; i++){
        int  m = i%2;
        if(m == 0)
            arr1[m/2] = m;
    }
    //------------
    clock_t ends = clock();
    t_mod1 = (double)(ends - start)/ CLOCKS_PER_SEC;

    //02模块:位运算
    clock_t start2 = clock();
    //测试块-----------
    int arr2[500000];
    for(int i = 0; i < 1000000; i++){
        int  m = i&1;
        if(m == 0)
            arr2[m/2] = m;
    }
    //------------
    clock_t ends2 = clock();
    t_bit1 = (double)(ends2 - start2)/ CLOCKS_PER_SEC;

    //03模块:求余
    clock_t start3 = clock();
    //测试块-----------
    int arr3[500000];
    for(int i = 0; i < 1000000; i++){
        int  m = i%2;
        if(m == 0)
            arr3[m/2] = m;
    }
    //------------
    clock_t ends3 = clock();
    t_mod2 = (double)(ends3 - start3)/ CLOCKS_PER_SEC;

    //04模块:位运算
    clock_t start4 = clock();
    //测试块-----------
    int arr4[500000];
    for(int i = 0; i < 1000000; i++){
        int  m = i&1;
        if(m == 0)
            arr4[m/2] = m;
    }
    //------------
    clock_t ends4 = clock();
    t_bit2 = (double)(ends4 - start4)/ CLOCKS_PER_SEC;

    return pair<double,double>( (t_mod1+t_mod2)/2,  (t_bit1+t_bit2)/2);
}

int main()
{
    double mod_time = 0, bit_time = 0;
    pair<double,double>res;
    int times = 100; //测试次数
    int win = 0;
    for(int i = 0; i < times; i++){
        res = testMod();
        mod_time += res.first;
        bit_time += res.second;
        if(res.first > res.second)
            win++;
    }
    cout<<"mod Time: "<<mod_time/times<<endl;
    cout<<"bit Time: "<<bit_time/times<<endl;
    cout<<"bit win: "<<win<<endl;
    return 0;
}

测试时，若main函数中的 times = 1时，差距不明显

mod Time: 0.0036635
bit Time: 0.0031245
bit win: 1

times = 10

mod Time: 0.00286435
bit Time: 0.0025851
bit win: 10

times = 100

mod Time: 0.00228572
bit Time: 0.00211616
bit win: 100

times = 1000

mod Time: 0.00221833
bit Time: 0.00208492
bit win: 996

可以看出，位运算总体还是优于求余运算的。