今天看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则为取模。

问：给定一个数x，x可以为整数也可以为负数，如何对x取模，模为Mod
 
答：x = ((x % Mod) + Mod) % Mod
 
具体应用 HDU - 6185
 
分析：此题是递推 + 矩阵快速幂，但是因为递推式中有一个数是负数，所以需要对负数进行模运算，否则后再n = 22（不止）时出错
 
参考博客：https://blog.csdn.net/elbadaernu/article/details/77825979
 
参考代码：
 
 
 
#include <stdio.h>
#include <string.h>

#define N 15
#define Mod 1000000007

typedef long long ll;

const int n = 4;

struct Matrix {
    ll a[N][N];
};

void print_mat(Matrix a) {
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            printf("%lld ", a.a[i][j]);
        }
        puts("");
    }
}

Matrix mul(Matrix a, Matrix b) {
    Matrix c; memset(c.a, 0, sizeof(c.a));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < n; ++k) {
                c.a[i][j] = (((c.a[i][j] + a.a[i][k] * b.a[k][j]) % Mod) + Mod) % Mod;
            }
        }
    }
    return c;
}

Matrix qpow(Matrix a, ll b) {
    Matrix res; memset(res.a, 0, sizeof(res.a));
    for (int i = 0; i < n; ++i) res.a[i][i] = 1;
    while (b) {
        if (b & 1) res = mul(res, a);
        a = mul(a, a);
        b >>= 1;
    }
    return res;
}

int main() {
    ll k;

    while (scanf("%lld", &k) != EOF) {
        ll val[N] = {0, 1, 5, 11, 36}, sum = 0;
        if (k <= 4) { printf("%lld\n", val[k]); continue; }

        Matrix res; memset(res.a, 0, sizeof(res.a));
        res.a[0][0] = 1; res.a[0][1] = 5; res.a[0][2] = 1; res.a[0][3] = -1;
        for(int i = 1; i < n; ++i) res.a[i][i - 1] = 1;

        res = qpow(res, k - 4);
        for (int i = 0; i < n; ++i) {
            sum = (sum + res.a[0][i] * val[4 - i]) % Mod;
        }
        printf("%lld\n", sum);
    }
    return 0;
}
 
 

#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;
}
 
 

 
本次项目目标：使用C++完成对于大数的相关运算，具体有加减乘除取模。
 
项目要点
 
1.大数指的是远超long long int的数据
 
2.将大数用矩阵进行存储，并通过矩阵实现运算
 
3.本人采用字符串进行存储，应注意char的特点
 
比如：char a=161；
 
cout<
 
此时会输出-95，而不是161，char类型首个比特位是作为正负号的
 
取模运算其实和取余差不多，主要是取模在负数方面与取余不同
 
需要用到之前博客提到的减法运算minus
 
核心思想：
 
先来看自然数的取模运算
 
与取余相同，与除法思路相同
 
比如861mod21=861%21
 
先用86去减21 知道数值小于21时停止 也就是2
 
再添加上下一位，就变成了21
 
如果这个数大于等于21，则再用这个数减去它
 
21-21=0，当已经取出最后一位，而且这个数字小于21时停止
 
即得出861%21=0
 
接下来来看负整数的情况
 
假设有一个正整数k,a，(-k) mod a+k mod a=0 mod a
 
(-k) mod a=0 mod a - k mod a
 
因为k mod a
 
所以(-k) mod a=a - k mod a
 
 
即一个负整数的模a，就为a-其绝对值的模a
 
 
运行截图及代码如下：
 
 

 
 
#include
 
 
#include
 
 
#include
 
 
using namespace std;
 
 
#define n 10
 
 
string dezero(string a)//用来去掉正数前面的0，也就是说可以输入000001类似这样的数字
 
 
{
 
 
long int i;
 
 
for(i=0;i
 
{
 
 
if(a.at(i)>48) break;
 
 
}
 
 
if(i==a.length()) return "0";
 
 
a.erase(0,i);
 
 
return a;
 
 
}
 
 
int judge(string a,string b)//判断两个正数的大小
 
 
{
 
 
if(a.length()>b.length()) return 1;
 
 
if(a.length()
 
long int i;
 
 
for(i=0;i
 
{
 
 
if(a.at(i)>b.at(i)) return 1;
 
 
if(a.at(i)
 
}
 
 
return 0;
 
 
}
 
 
string minus(string a,string b)//自然数减法(在之前博客中写到过，这里直接挪过来调用了)
 
 
{
 
 
a=dezero(a);
 
 
b=dezero(b);
 
 
long int i,j=0;
 
 
string c="0";
 
 
string c1,c2;
 
 
string d="-";
 
 
if(judge(a,b)==0) return c;
 
 
if(judge(a,b)==1)
 
 
{
 
 
c1=a;
 
 
c2=b;
 
 
}
 
 
if(judge(a,b)==-1)
 
 
{
 
 
c1=b;
 
 
c2=a;
 
 
j=-1;
 
 
}
 
 
reverse(c1.begin(),c1.end());
 
 
reverse(c2.begin(),c2.end());
 
 
for(i=0;i
 
{
 
 
if(c2.at(i)>=48&&c2.at(i)<=57) c2.at(i)-=48;
 
 
if(c2.at(i)>=97&&c2.at(i)<=122) c2.at(i)-=87;
 
 
}
 
 
for(i=0;i
 
{
 
 
if(c1.at(i)>=48&&c1.at(i)<=57) c1.at(i)-=48;
 
 
if(c1.at(i)>=97&&c1.at(i)<=122) c1.at(i)-=87;
 
 
}
 
 
for(i=0;i
 
{
 
 
c1.at(i)=c1.at(i)-c2.at(i);
 
 
}
 
 
for(i=0;i
 
{
 
 
if(c1.at(i)<0)
 
 
{
 
 
c1.at(i)+=n;
 
 
c1.at(i+1)--;
 
 
}
 
 
}
 
 
for(i=c1.length()-1;i>=0;i--)
 
 
{
 
 
if(c1.at(i)>0) break;
 
 
}
 
 
c1.erase(i+1,c1.length());
 
 
for(i=0;i
 
{
 
 
if(c1.at(i)>=10) c1.at(i)+=87;
 
 
if(c1.at(i)<10) c1.at(i)+=48;
 
 
}
 
 
reverse(c1.begin(),c1.end());
 
 
if(j==-1) c1.insert(0,d);
 
 
return c1;
 
 
}
 
 
string mod(string a,string b)//取模运算
 
 
{
 
 
long int i,j=0;
 
 
string c1,c2,c3,d;
 
 
if(a.at(0)=='-') j=1;
 
 
if(judge(a,b)==0) return "0";
 
 
if(judge(a,b)==-1)
 
 
{
 
 
return a;
 
 
}
 
 
c1=dezero(a);
 
 
c2=dezero(b);
 
 
d="";
 
 
for(i=0;i
 
{
 
 
d=d+c1.at(i);
 
 
while(judge(d,b)>=0)
 
 
{
 
 
d=minus(d,b);
 
 
d=dezero(d);
 
 
}
 
 
}
 
 
if(j==1) d=minus(b,d);
 
 
return d;
 
 
}
 
 
int main()
 
 
{
 
 
string a,b;
 
 
while(cout<>a>>b)
 
 
{
 
 
cout<
 
 
}
 
 
return 0;
 
 
}
 
 
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持猪先飞。