今天看c++primer5遇到了这个-1对256取模，负数取模还真的不清楚，所以查了查资料，供大家参考。
原文是这样说的：C++中，把负值赋给unsigned 对象是完全合法的，其结果是初始值对无符号类型表示数值总数取模后的余数。所以，如果把-1赋给8位的unsigned char，那么结果是255，因为255是-1对256求模后的值。


从数学角度解读：

取模运算时,对于负数,应该加上被除数的整数倍,使结果大于或等于0之后,再进行运算.

也就是：(-1)%256 = (-1+256)%256=255%256=255


计算机存储角度：

计算机中负数是以补码形式存储的，-1的补码11111111，转换成无符号数即是255的二进制编码。


数据类型转换角度：（以下引用csdn论坛的多位答主的回答）
这个运算其实就是数据类型的提升和隐式转化的问题

如果是

　　unsigned char a = -1;

那么a%256经过了这么几步,

　　1.a 从 unsigned char 类型提升到 int,就是 0x000000ff

　　2.然后0x000000ff 与256取模 就是 0x000000ff


下面把 a%256的结果(0x000000ff)赋给一个变量,这一步会导致输出的值到底是-1还是255,

第一种可能：

unsigned char b = a%256; //0x000000ff从int转化为unsign char发生字节截断 就变为0xff
printf("%d",b);          //0xff从 unsigned char 类型提升到 int,就是 0x000000ff 所以输出应该为255


第2种可能：

char b = a%256; //0x000000ff从int转化为char发生字节截断 就变为0xff
printf("%d",b); //0xff从 char 类型提升到 int,就是 0xffffffff,这里是关键,有符号和无符号数的类型提升,
编译器采取不同的处理方式, 所以输出应该为-1


当然你直接输出

printf("%d",a%256);//其实就是把0x000000ff直接输出,那应该是255

另外如果是

　　char a = -1; 也可以根据类型提升和隐式转换得出结果,这个跟编译器应该没什么关系.
一般来说(char,unsigned char,short,unsigned short)在做运算时候都会被类型提升到 int,

　　再从int转化到float(如果有)什么的,最后在根据目标变量类型,把算出来的中间结果进行类型转化,

　　就可以得到结果,
再举个例子
　unsigned char a = 0x1;
　unsigned char b = 0xff;
　unsigned char c = a+b; //c 的结果是 0x0;
　int d = a+b;//d的结果是0x00000100

c++一段代码验证：
1 unsigned char uc;    //声明一个无符号的字符，8位的，无符号字符类型的取值个数为256。
2 uc=-1;               //将-1赋给无符号的字符型对象（变量），
3                      //此过程会先将-1自动转换为无符号数，即 11111111 11111111，然后赋值给uc
4                      //但是uc只有8位，所以只保存了 11111111 11111111 的低8位数据，其它的位
5                      //就因为溢出而丢失了。-----因为溢出而丢失了其它位，就相当于取模运算了。
6 cout<<"uc as int is :"<<int(uc)<<endl;    //这一行将uc转换为整型输出，结果为255
7 //注意，11111111 11111111 是十六位的，但实际上也可能是32位的，因为我们现在的计算机都是32位的了。

再贴上摘自百度百科的取模和取余的区别：
取模运算（“Modulo Operation”）和取余运算（“Remainder Operation”）两个概念有重叠的部分但又不完全一致。主要的区别在于对负整数进行除法运算时操作不同。取模主要是用于计算机术语中。取余则更多是数学概念。
对于整型数a，b来说，取模运算或者求余运算的方法都是：

1.求 整数商： c = a/b;

2.计算模或者余数： r = a - c*b.

求模运算和求余运算在第一步不同: 取余运算在取c的值时，向0 方向舍入(fix()函数)；而取模运算在计算c的值时，向负无穷方向舍入(floor()函数)。

例如：计算-7 Mod 4

那么：a = -7；b = 4；

第一步：求整数商c，如进行求模运算c = -2（向负无穷方向舍入），求余c = -1（向0方向舍入）；

第二步：计算模和余数的公式相同，但因c的值不同，求模时r = 1，求余时r = -3。

归纳：当a和b符号一致时，求模运算和求余运算所得的c的值一致，因此结果一致。

当符号不一致时，结果不一样。求模运算结果的符号和b一致，求余运算结果的符号和a一致。

另外各个环境下%运算符的含义不同，比如c/c++，java 为取余，而python则为取模。

#include "iostream"
#include "cstdio"
#include "cstring"
using namespace std;
char s[10000005];
int main(){
    int t=1;
    while(scanf("%s",s)!=EOF){
        int len=strlen(s);
        int ans=0;
        for(int i=0;i<len;i++)
            ans=(int)(((long long)ans*10+s[i]-'0')%10001);
        if(!ans)
            printf("Case #%d: YES\n",t);
        else 
            printf("Case #%d: NO\n",t);
        t++;
    }
    return 0;
}


 

头文件：#include <math.h>
fmod() 用来对浮点数进行取模（求余），其原型为：
double fmod (double x);

设返回值为 ret，那么 x = n * y + ret，其中 n 是整数，ret 和 x 有相同的符号，而且 ret 的绝对值小于 y 的绝对值。如果 x = 0，那么 ret = NaN。
fmod 函数计算 x 除以 y 的 f 浮点余数，这样 x = i*y + f，其中 i 是整数，f 和 x 有相同的符号，而且 f 的绝对值小于 y 的绝对值。
fmod()与求模运算符%的对比

% 运算符

% 只用于整型的计算，后一个数不能是0，参与运算的数据可正可负。

对于x%y ，计算之后结果的正负与 x 的符号相同，如果前者是较小的数，后者是较大的数，那么，结果直接为较小的数。例如：
10%3＝1
3%10＝3
10%-3＝1

-3%10＝-3
-10%-3＝-1
-3%-10＝-3

3%13＝3

0%3＝0
0%-3＝0

3%0  (×)Error!
-3%0  (×)Error!
10.0%3.0 (×)Error!  // 浮点型不能进行模运算


fmod()函数

fmod()函数可以对浮点型数据进行取模运算，后一个数可为0，这时函数返回NaN。

计算后结果的符号与前者(x)相同，如果前者是较小的数，后者是较大的数，那么结果直接为较小的数。
举例如下：
float x=10.0;
float y=-3.0;
float z=3.0;
result=fmod(x,z);
printf("10.0%%3.0= %f/n",result); //1.0
result=fmod(z,x);
printf("3.0%%10.0= %f/n",result); //3.0
result=fmod(x,y);
printf("10.0%%-3.0= %f/n",result); //1.0
result=fmod(y,x);
printf("-3.0%%10.0= %f/n",result); //-3.0
result=fmod(0,z);
printf("0.0%%3.0= %f/n",result); //0.0
result=fmod(0,y);
printf("0.0%%-3.0= %f/n",result); //0.0
result=fmod(3,13);
printf("3%%-13= %f/n",result); //3
result=fmod(10.1,3.1);
printf("10.1%%3.1= %f/n",result); //0.8
result=fmod(10.9,3.9);
printf("10.9%%3.9= %f/n",result); //3.1


【实例】代码如下。
#include <stdio.h>
#include <math.h>
int main ()
{
printf ( "fmod of 5.3 / 2 is %f\n", fmod (5.3,2) );
printf ( "fmod of 18.5 / 4.2 is %f\n", fmod (18.5,4.2) );
return 0;
}

输出结果：
fmod of 5.3 / 2 is 1.300000
fmod of 18.5 / 4.2 is 1.700000


转载于:https://www.cnblogs.com/xiaonanxia/p/5786668.html

long long mul_mod(long long a,long long b,long long m)      //a个b相加，结果对m取模
{
    long long t=0;
    while(b)
    {
        if(b&1)
        {
            t+= a%m;
            t%=m;
        }
        a<<=1;
        b>>=1;
        a%=m;

    }
    return t;
}



如果a与b十分大时，就必须采用这个方法了，背下。
还有种方法：
int mod(char str[],int num)
{
    int number[100];
    for(int i=0;i<strlen(str);i++)
     number[i]=str[i]-'0';
    int remainder=0;
    for(int i=0;i<strlen(str);i++)
    {
        remainder=((long long)remainder*10+number[i])%num;
    }
    return remainder;
}