设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 程序设计/上位机 › 大整数(25000位)的四则运算C语言源程序
返回列表 发新帖
查看: 4086|回复: 5
收起左侧

大整数(25000位)的四则运算C语言源程序

[复制链接]
ID:166089 发表于 2018-7-2 10:43 | 显示全部楼层 |阅读模式
研究密码学过程中，遇到数据位比较长，c语言本身具有的数据类型无法满足超长位数的整数进行四则运算，因此特意写了这个程序。
参考了网上部分类似代码，目前网上能找到的类似代码，基本都有部分瑕疵，本文将我发现的瑕疵全部改进。
本文能实现25000位整数的加减乘除运算，经过本人的测试，基本正常。最大位数只验证了4位，25000位未验证。希望有兴趣的黑友，帮忙下载测试，若发现问题，希望能在评论中提出，我将会及时改进，谢谢。
以下代码在vc6.0中编译运行通过，将下列代码全部放于一个.c文件中即可。
关于程序细节方面，见下文的程序注释。
  1. /**************************************************************
  2. *功能：实现大整数的加减乘除四则运算，最大位长为MAX-1,1为符号位
  3. *思路：利用数组实现，尽量将四则运算封装成函数；
  4. *     1.开始菜单；数组初始化，避免影响第二次运算结果接收数据；提示信息
  5. *     2.接收数据
  6. *     3.先判断进行哪种运算(加减乘除退出),再判断输入的两个数据是否为0
  7. *      (加减时，若ab都为0,则直接输出结果0;乘时,则ab任一为0,则直接输出结果0;
  8. *       除时,b为0,则输出提示“输入错误”,b不为0a为0，则直接输出结果0);
  9. *     4.再判断a和b的符号
  10. *       加时:同号相加则调加;+-相加则将-变+再调减;-+相加,将-变+,再调换成+-,再调减
  11. *       减时:++相减则调减;+-相减则将-变+再调加;-+相减则将+变-再调加;--相减，将-变+再交换ab值,再调减
  12. *       乘时:异号相乘结果添'-'号,同号相乘不处理;ab符号皆调正，子函数不处理符号位
  13. *       除时:异号相除结果添'-'号,同号相乘不处理;ab符号皆调正，子函数不处理符号位;若有小数则,则用余数形式显示。
  14. *     5.调用子函数处理数据
  15. *     5.输出结果
  16. *注意!!:数组定义大小要注意，计算结果有的比最大位数大1,有的大2倍+1;
  17. *       因内存限制了数组下标，MAX最大值为25001，本程序运行正常;超出此值，程序运行将出现问题!!!
  18. *测试数据:加法：0+0=0;0+5=5;5+0=5;5+5=10;5+(-8)=-3;(-8)+5=-3;(-5)+(-5)=-10
  19. *               11+12=23;11+123=134;123+11=134; -11+12=1;-11+123=112;-123+11=-112
  20. *               80848+36678623=36759471;-2998602+(-44953)=-3043555;-8+39639213=39639205
  21. *         减法：0-0=0;0-5=-5;5-0=5;5-5=0;5-(-8)=13;(-8)-5=-13;(-5)-(-5)=0
  22. *               11-12=-1;11-123=-112;123-11=112; -11-12=-23;-11-123=-134;-123-11=-134;
  23. *               -5429891960-(5838364)=-5435730324;5039-(-41490954)=41495993
  24. *         乘法：0*0=0;0*5=0;5*0=0;5*5=25;5*(-8)=-40;(-8)*5=-40;(-5)*(-5)=25
  25. *                                11*12=132;11*123=1353;123*11=1353; -11*12=-132;-11*123=-1353;-123*11=-1353;
  26. *               -49*(-128)=6272   4268*13197386=56326443448
  27. *         除法：0/0=--;0/5=0;5/0=--;5/5=1;5/(-8)=-0……5;(-8)/5=-1……3;(-5)/(-5)=1
  28. *               11/12=0……11;11/123=0……11;123/11=11……2; -11/12=-0……11;-11/123=-0……11;-123/11=-11……2;
  29. *               043714/956540=0(输入数据不规范)默认数据最高位非0
  30. *               7425776/338=21969……254
  31. *               8784015415/3545=2477860……1715
  32. *         将#define MAX 25001  改为  #define MAX 5;再将a=b=9999，分别进行加减乘除，结果分别为19998、0、99980001、1
  33. *         验证最大位数计算正确与否                 再将a=b=-9999，分别进行加减乘除，结果分别为-19998、0、99980001、1
  34. *         验证结束后，根据实际情况，改其值         再将a=9999,b=-9999，分别进行加减乘除，结果分别为0、19998、-99980001、-1
  35. *                                                  再将a=-9999,b=9999，分别进行加减乘除，结果分别为0、-19998、-99980001、-1
  36. **************************************************************/

  38. #include <stdio.h>
  39. #define MAX 25001    // 大数的最大位数,包括一位符号位，实际数字位数为MAX-1

  41. /*****************************************
  42. *功能说明：打印菜单函数
  43. *          仅提示用户选择何种运算
  44. *          不接收不判断数据
  45. *****************************************/
  46. void menu()  //菜单
  47. {        
  48.         printf("===============大整数(最大数字位数25000位)计算器==================\n");
  49.         printf("1.加法 2.减法 3.乘法 4.除法 0.退出\n");
  50.         printf("请从0~4中选择:");
  51. }

  53. /*****************************************
  54. *功能说明: 读入所要计算的数值，数据初始化
  55. *参数说明: a[]第一个数值, b[]第二个数值
  56. *          *p1第一个数值长度(包括符号位)
  57. *          *p2第二个数值长度(包括符号位)
  58. *其他说明: 参数传递都采用传地址的方式,
  59. *          调用本函数前，需要提前定义好相关变量  
  60. *          数组存储数据为大端方式：
  61. *          即：数值-12在数组中的下标依次为0,1,2
  62. *          数组第0位为符号位,0为正，非0为负
  63. *****************************************/
  64. void init(int a[], int b[], int *p1, int *p2)  // 输入
  65. {
  66.         int i,j;
  67.         char r,s;
  68.         for(i=0;i<MAX;i++)  // 数组清零，以确保第二次之后的运行结果不受影响
  69.         {
  70.                 a[i]=0;
  71.                 b[i]=0;
  72.         }
  73.         printf("请输入(0123456789+-)中的任意字符\n请输入第一个(a)数值：");  // 默认输入正确，不进行判断
  74.         r=getchar();
  75.         if(r=='-')   // "-" 输入负数
  76.         {
  77.                 a[0]=r;
  78.                 for(i=1;(r=getchar())!='\n';i++)
  79.                         a[i]=r-48;
  80.         }
  81.         else  // 输入正数
  82.         {
  83.                 a[1]=r-48;
  84.                 for(i=2;(r=getchar())!='\n';i++)
  85.                         a[i]=r-48;
  86.         }
  87.         *p1=i;
  88.         
  89.         printf("请输入第二个(b)数值："); // 默认输入正确，不进行判断
  90.         s=getchar();
  91.         if(s=='-')  
  92.         {
  93.                 b[0]=s;
  94.                 for(j=1;(s=getchar())!='\n';j++)
  95.                         b[j]=s-48;
  96.         }
  97.         else  
  98.         {
  99.                 b[1]=s-48;
  100.                 for(j=2;(s=getchar())!='\n';j++)
  101.                         b[j]=s-48;
  102.         }
  103.         *p2=j;
  104. }

  106. /*****************************************
  107. *功能说明: 两个同号整数相加(++、--)
  108. *参数说明: a[]第一个数值, b[]第二个数值
  109. *          c[]第一二数值相加的结果
  110. *          返回值i为c[]数组的长度，即结果的实际长度
  111. *          m第一个数值长度(包括符号位)
  112. *          n第二个数值长度(包括符号位)
  113. *其他说明: 数组参数传递采用传地址的方式,
  114. *          调用本函数前，需要提前定义好相关变量
  115. *          a[],b[],c[]数组存储数据为大端方式：
  116. *          即：数值-12在数组中的下标依次为0,1,2
  117. *                   d[]数组存储数据为小端方式：
  118. *          即：数值-12在数组中的下标依次为2,1,0
  119. *****************************************/
  120. int plus(int a[], int b[], int c[], int m, int n)  //加法运算
  121. {        
  122.         int d[MAX+1]={0},i,j,k;   // 和比最大位数可能长1位
  123.         if(a[1]==0)   // 处理a+b时，有a为0的情况
  124.         {
  125.                 for(i=0;i<n;i++)
  126.                         c[i]=b[i];
  127.                 return(i);
  128.         }
  129.         if(b[1]==0)  // 处理a+b时，有b为0的情况
  130.         {
  131.                 for(i=0;i<m;i++)
  132.                         c[i]=a[i];
  133.                 return(i);
  134.         }
  135.         
  136.         for(i=m-1,j=n-1,k=1;i>0&&j>0;i--,j--,k++)  // 处理a+b时，有a,b都不为0的情况
  137.         {
  138.                 d[k]=a[i]+b[j]+d[k];
  139.                 if(d[k]>9)  // 处理和进位的情况
  140.                 {
  141.                         d[k+1]=1;
  142.                         d[k]=d[k]-10;
  143.                 }
  144.         }
  145.         while(i>0)  // 处理a+b时, a长度>b长度的情况
  146.         {
  147.                 d[k]=d[k]+a[i];
  148.                 if(d[k]>9)  
  149.                 {
  150.                         d[k+1]=1;
  151.                         d[k]=d[k]-10;
  152.                 }
  153.                 k++;                 
  154.                 i--;
  155.         }  
  156.         while(j>0) // 处理a+b时, a长度<b长度的情况
  157.         {
  158.                 d[k]=d[k]+b[j];
  159.                 if(d[k]>9)  
  160.                 {
  161.                         d[k+1]=1;
  162.                         d[k]=d[k]-10;
  163.                 }
  164.                 k++;
  165.                 j--;
  166.         }
  167.         d[0]=a[0]+b[0];
  168.         c[0]=d[0];
  169.         if(d[k]==0) // 数值和最高位没有进位
  170.                 k--;
  171.         for(i=1;k>0;i++,k--)
  172.                 c[i]=d[k];
  173.         return(i);
  174. }

  176. /*****************************************
  177. *功能说明: 两个正整数相减 (++)
  178. *参数说明: a[]第一个数值, b[]第二个数值
  179. *          c[]第一二数值相减的结果
  180. *          返回值i为d[]数组的长度，即结果的实际长度
  181. *          m第一个数值长度(包括符号位)
  182. *          n第二个数值长度(包括符号位)
  183. *其他说明: 数组参数传递采用传地址的方式,
  184. *          调用本函数前，需要提前定义好相关变量
  185. *          a[],b[],c[]数组存储数据为大端方式：
  186. *          即：数值-12在数组中的下标依次为0,1,2
  187. *                   d[]数组存储数据为小端方式：
  188. *          即：数值-12在数组中的下标依次为2,1,0
  189. *****************************************/
  190. int minus(int a[], int b[], int c[], int m, int n) //减法运算
  191. {
  192.         int d[MAX+1]={0},i,j,k,T;  // 多一位可能存在的借位位
  193.         
  194.         if (m<n) // a<b 位
  195.         {
  196. a:                T=m;
  197.                 m=n;
  198.                 n=T;
  199.                 for(i=m-1,j=n-1,k=1;i>0&&j>0;i--,j--,k++)  
  200.                 {
  201.                         if(d[k]<0||b[i]<a[j]) // 有借位情况
  202.                         {
  203.                                 d[k]=d[k]+b[i]-a[j];
  204.                                 if(d[k]<0)
  205.                                 {
  206.                                         d[k]+=10;
  207.                                         d[k+1]=-1;
  208.                                 }
  209.                         }
  210.                         else  // 无借位情况
  211.                                 d[k]=b[i]-a[j];
  212.                 }
  213.                 while(i>0)  
  214.                 {
  215.                         d[k]=d[k]+b[i];
  216.                         if(d[k]<0)  
  217.                         {
  218.                                 d[k]+=10;
  219.                                 d[k+1]--;
  220.                         }
  221.                         k++;
  222.                         i--;
  223.                 }
  224.                 d[k]=b[i]+d[k];                 
  225.                 while(d[k]<=0&&k>0)  
  226.                         k--;
  227.                 for(i=1;k>0;i++)  
  228.                         c[i]=d[k--];
  229.                 c[0]=45;
  230.                 return(i);
  231.         }
  232.         if(m>n)  // a>b 位
  233.         {               
  234. b:                for(i=m-1,j=n-1,k=1;i>0&&j>0;i--,j--,k++)  
  235.                 {
  236.                         if(d[k]<0||a[i]<b[j]) // 有借位情况
  237.                         {
  238.                                 d[k]=d[k]+a[i]-b[j];
  239.                                 if(d[k]<0)
  240.                                 {
  241.                                         d[k]+=10;
  242.                                         d[k+1]=-1;
  243.                                 }
  244.                         }
  245.                         else  // 无借位情况
  246.                                 d[k]=a[i]-b[j];
  247.                 }
  248.                 while(i>0)  
  249.                 {
  250.                         d[k]=d[k]+a[i];
  251.                         if(d[k]<0)  
  252.                         {
  253.                                 d[k]+=10;
  254.                                 d[k+1]--;
  255.                         }
  256.                         k++;
  257.                         i--;
  258.                 }
  259.                 d[k]=a[i]+d[k];
  260.                
  261.                 while(d[k]<=0&&k>0)  
  262.                         k--;
  263.                 for(i=1;k>0;i++)  
  264.                         c[i]=d[k--];
  265.                 return(i);
  266.         }
  267.         // a==b 位数
  268.         {
  269.                 for(i=1; i<m; i++)
  270.                 {
  271.                         if(a[i]>b[i])  // a>b 数值
  272.                                 goto b;
  273.                         else if(a[i]<b[i]) // a<b 数值
  274.                                 goto a;
  275.                 }
  276.                 c[0]=0; //a=b
  277.                 c[1]=0;
  278.                 return 2;
  279.         }
  280. }

  282. /*****************************************
  283. *功能说明: 两个整数相乘
  284. *注：函数运算过程中未处理符号
  285. *参数说明: a[]第一个数值, b[]第二个数值
  286. *          c[]第一二数值相乘的结果
  287. *          返回值k为c[]数组的长度，即结果的实际长度(包括符号位)
  288. *          m第一个数值长度(包括符号位)
  289. *          n第二个数值长度(包括符号位)
  290. *其他说明: 数组参数传递采用传地址的方式,
  291. *          调用本函数前，需要提前定义好相关变量
  292. *          a[],b[],c[]数组存储数据为大端方式：
  293. *          即：数值-12在数组中的下标依次为0,1,2
  294. *                   d[]数组存储数据为小端方式：
  295. *          即：数值-12在数组中的下标依次为2,1,0
  296. *★ Comba 乘法 （Comba  Multiplication）原理实现
  297. *        Comba 乘法以（在密码学方面）不太出名的 Paul G. Comba 得名。
  298. *        和普通的笔算乘法很类似，只是每一次单精度乘法只是单纯计算乘法，不计算进位，进位留到每一列累加后进行。
  299. *        Comba 乘法无需进行嵌套进位来计算乘法,时间复杂度和基线乘法一样
  300. *        Comba 乘法则按列计算，先累加，然后传递进位，减少了计算量，所以速度快。
  301. ************************************************************/
  302. int multi(int a[], int b[], int c[], int m, int n)  //正整数乘法运算
  303. {        
  304.         int d[2*MAX+1]={0},i,j,k,s;
  305.         for(i=0;i<MAX;i++)
  306.                 c[i]=0;
  307.         if(m<=n)  // a位数大于等于b位数
  308.         {
  309.                 for(i=m-1,s=1;i>0;i--,s++)         // 单纯计算乘法，不计算进位               
  310.                 {
  311.                         for(j=n-1,k=1*s;j>0;j--,k++)
  312.                         {
  313.                                 d[k]=a[i]*b[j]+d[k];
  314.                         }
  315.                 }               
  316.                 for(i=1;i<k;i++)   // 处理进位                        
  317.                 {
  318.                         if(d[i]>9)
  319.                         {
  320.                                 d[i+1]=d[i+1]+d[i]/10;
  321.                                 d[i] = d[i]%10;
  322.                         }
  323.                 }
  324.                 if(d[i]==0) // 数值和最高位没有进位
  325.                         i--;
  326.                 for(k=1;i>0;k++,i--)
  327.                         c[k]=d[i];
  328.                 return k;
  329.         }
  330.         else  // a位数大于b位数
  331.         {
  332.                 for(i=n-1,s=1;i>0;i--,s++)         // 单纯计算乘法，不计算进位               
  333.                 {
  334.                         for(j=m-1,k=1*s;j>0;j--,k++)
  335.                         {
  336.                                 d[k]=b[i]*a[j]+d[k];
  337.                         }
  338.                 }
  339.                 // 处理进位
  340.                 for(i=1;i<k;i++)                        
  341.                 {
  342.                         if(d[i]>9)
  343.                         {
  344.                                 d[i+1]=d[i+1]+d[i]/10;
  345.                                 d[i] = d[i]%10;
  346.                         }
  347.                 }
  348.                 if(d[i]==0) // 数值和最高位没有进位
  349.                         i--;
  350.                 for(k=1;i>0;k++,i--)
  351.                         c[k]=d[i];
  352.                 return k;
  353.         }
  354. }

  356. /*****************************************
  357. *功能说明: 用长度为len1的大整数p1减去长度为len2的大整数p2
  358. *          结果存在p1中，返回值代表结果的长度
  359. *          不够减：返回-1 ， 正好够：返回0
  360. *数组数值为：p1,p2小端
  361. *其他说明: 数组参数传递采用传地址的方式,
  362. *          调用本函数前，需要提前定义好相关变量
  363. *          本函数的作用仅与Division函数结合实现除法
  364. *****************************************/
  365. int SubStract(int *p1, int len1, int *p2, int len2)
  366. {
  367.         int i;
  368.         if(len1 < len2)
  369.                 return -1;
  370.         if(len1 == len2 )
  371.         {                        // 判断p1 > p2
  372.                 for(i = len1-1; i >= 0; i--)
  373.                 {
  374.                         if(p1[i] > p2[i])   // 若大，则满足条件，可做减法
  375.                                 break;
  376.                         else if(p1[i] < p2[i]) // 否则返回-1
  377.                                 return -1;
  378.                 }
  379.         }
  380.         for(i = 0; i <= len1-1; i++)  // 从低位开始做减法
  381.         {
  382.                 p1[i] -= p2[i];         // 相减
  383.                 if(p1[i] < 0)           // 若是否需要借位
  384.                 {   // 借位
  385.                         p1[i] += 10;
  386.                         p1[i+1]--;
  387.                 }
  388.         }
  389.         for(i = len1-1; i >= 0; i--)  // 查找结果的最高位
  390.         {
  391.                 if( p1[i] )             //最高位第一个不为0
  392.                         return (i+1);       //得到位数并返回
  393.         }
  394.         return 0;                   //两数相等的时候返回0
  395. }

  397. /*****************************************
  398. *功能说明: 大数除法---结果不包括小数点
  399. **注：函数运算过程中未处理符号
  400. *参数说明: a[]被除数  b[]除数
  401. *          c[]第一二数值相除的结果即：a/b=c
  402. *          返回值len为c[]数组的长度，即结果的实际长度
  403. *          m第一个数值长度(包括符号位)
  404. *          n第二个数值长度(包括符号位)
  405. *          *p表示余数的位数，位数大于0时,表示有余数；否则无余数
  406. *          num_a[]保存最后余数的
  407. *其他说明: 数组参数传递采用传地址的方式,
  408. *          调用本函数前，需要提前定义好相关变量
  409. *          a[],b[],c[],num_a[]数组存储数据为大端方式：
  410. *          即：数值-12在数组中的下标依次为0,1,2
  411. *****************************************/
  412. int Division(int a[], int b[], int c[] , int m, int n, int *p, int num_a[])
  413. {
  414.         int i, j;
  415.         int len=0;
  416.         int nTimes;                //两大数相差位数
  417.         int nTemp;                 //Subtract函数返回值
  418.         int num_b[MAX] = {0};      //除数
  419.         int num_c[MAX+1] = {0};      //商         
  420.         if( m < n )          //如果被除数小于除数，直接返回-1，表示结果为0……a
  421.         {
  422.                 return -1;
  423.         }        
  424.         if(m==n)
  425.         {
  426.                 for(i=1; i<m; i++)                        
  427.                 {
  428.                         if(a[i]>b[i]) // 够减一次否
  429.                                 break;
  430.                 }
  431.                 if(i==m && a[m-1]<b[m-1]) // 包含符号位
  432.                         return -1;  // 如果被除数小于除数，直接返回-1，表示结果为0……a
  433.                
  434.         }
  435.         nTimes = m - n;    //相差位数        
  436.         //翻转保存的数据
  437.         for( j = 1, i = m-1; i >= 0; j++, i-- )
  438.                 num_a[j] = a[i];
  439.         for( j = 1, i = n-1; i >= 0; j++, i-- )
  440.                 num_b[j] = b[i];
  441.         
  442.         for ( i=m-1; i>=0; i-- )    //将除数扩大，使得除数和被除数位数相等
  443.         {
  444.                 if ( i>=nTimes )
  445.                         num_b[i] = num_b[i-nTimes];
  446.                 else                     //低位置0
  447.                         num_b[i] = 0;
  448.         }
  449.         n=m;
  450.         
  451.         for( j=0; j<=nTimes; j++ )      //重复调用，同时记录减成功的次数，即为商
  452.         {
  453.                 while((nTemp = SubStract(num_a,m,num_b + j,n - j)) >= 0)
  454.                 {
  455.                         m = nTemp;      //结果长度
  456.                         num_c[nTimes-j]++;//每成功减一次，将商的相应位加1
  457.                 }
  458.         }        
  459.         if(nTemp<0)
  460.                 *p=m; // 有余数
  461.         else
  462.                 *p=0; //无余数
  463.         
  464.         // 计算商的位数，并将商放在c数组中
  465.         for(i = MAX-1; num_c[i] == 0 && i >= 0; i-- );  //跳过高位0，获取商的位数
  466.         if(i >= 0)
  467.                 len = i + 1; // 保存位数
  468.         for(j = 1; i >= 0; i--, j++)     // 将结果复制到c数组中
  469.         {
  470.                 c[j] = num_c[i];
  471.         }
  472.         return len+1;      // 返回商的位数
  473. }

  475. //功能说明：主函数，调用其余函数，计算相应功能的值并输出
  476. int main()
  477. {        
  478.     //积的位数最多是因数位数的两倍
  479.         int a[MAX]={0}, b[MAX]={0}, c[2*MAX+1]={0}, Temp[MAX]={0};
  480.         int m,n;
  481.         int *p1,*p2;         
  482.         int i, j;
  483.         int select;
  484.         int len;
  485.         int remainder;        
  486.         p1=&m;
  487.         p2=&n;        
  488.         while(1)
  489.         {
  490.                 for(i=0;i<MAX;i++) // 初始化0,避免影响下一次运行
  491.                 {
  492.                         a[i]=0;
  493.                         b[i]=0;
  494.                         c[i]=0;
  495.                         Temp[i]=0;
  496.                 }
  497.                 for(;i<2*MAX+2;i++) // 初始化0,避免影响下一次运行
  498.                 {
  499.                         c[i]=0;
  500.                 }
  501.                 menu();    // 仅输出提示信息
  502.                 select=getchar(); // 获得四则运算中的一个(1加2减3乘4除0退出)
  503.                 getchar();  // 处理选择时候的回车，避免第二次运行无法重新选择0~4
  504.                 if(select =='0')
  505.                         return 0;  // 退出程序
  506.                 else if(!(select>'0'&&select<'5'))        
  507.                 {
  508.                         printf("输入错误!\n请从0~4中选择一个数输入!!\n\n");
  509.                         continue;
  510.                 }
  511.                 init(a,b,p1,p2);  //  获取两个数值
  512.                 switch(select)
  513.                 {                 
  514.                 case '1':
  515.                         {
  516.                                 if(a[1]==0&&b[1]==0) // 两0相加
  517.                                 {
  518.                                         printf("a+b=0\n\n");  
  519.                                         break;
  520.                                 }
  521.                                 printf("a+b=");                 
  522.                                 if(a[0]==b[0]) // 同号相加则调加
  523.                                 {
  524.                                         j=plus(a, b, c, m, n);  //加法运算
  525.                                         if(c[0]!=0)  
  526.                                                 printf("-");
  527.                                         for(i=1;i<j;i++)
  528.                                                 printf("%d",c[i]);
  529.                                         printf("\n\n");
  530.                                         break;
  531.                                 }
  532.                                 if(a[0]==0 && b[0]!=0) // +-相加则将-变+再调减
  533.                                 {
  534.                                         b[0]=0; // 将b的符号变为+
  535.                                         j=minus(a, b, c, m, n); //减法运算
  536.                                         if(c[0]!=0)  
  537.                                                 printf("-");
  538.                                         for(i=1;i<j;i++)
  539.                                                 printf("%d",c[i]);
  540.                                         printf("\n\n");
  541.                                         break;
  542.                                 }
  543.                                 // -+相加,将-变+,再调换成+-,再调减
  544.                                 {
  545.                                         a[0]=0; // 将-变+
  546.                                         // 交换a，b数值
  547.                                         for(i=1; i<(m>n?m:n); i++)
  548.                                         {
  549.                                                 Temp[i]=a[i];
  550.                                                 a[i]=b[i];
  551.                                                 b[i]=Temp[i];
  552.                                         }
  553.                                         // 交换a，b位数
  554.                                         i=m;
  555.                                         m=n;
  556.                                         n=i;
  557.                                         j=minus(a, b, c, m, n); //减法运算
  558.                                         if(c[0]!=0)  
  559.                                                 printf("-");
  560.                                         for(i=1;i<j;i++)
  561.                                                 printf("%d",c[i]);
  562.                                         printf("\n\n");
  563.                                         break;                                         
  564.                                 }
  565.                         }               
  566.                 case '2':
  567.                         {
  568.                                 if(a[1]==0&&b[1]==0) // 两0相减
  569.                                 {
  570.                                         printf("a-b=0\n\n");  
  571.                                         break;
  572.                                 }
  573.                                 printf("a-b=");
  574.                                 if(a[0]==0&&b[0]==0) // ++相减则调减
  575.                                 {
  576.                                         j=minus(a, b, c, m, n); //减法运算
  577.                                         if(c[0]!=0)  
  578.                                                 printf("-");
  579.                                         for(i=1;i<j;i++)
  580.                                                 printf("%d",c[i]);
  581.                                         printf("\n\n");
  582.                                         break;
  583.                                 }
  584.                                 if(a[0]==0&&b[0]!=0) // +-相减则将-变+再调加
  585.                                 {
  586.                                         b[0]=0; // 将b的符号变为+
  587.                                         j=plus(a, b, c, m, n);  //加法运算  
  588.                                         if(c[0]!=0)  
  589.                                                 printf("-");
  590.                                         for(i=1;i<j;i++)
  591.                                                 printf("%d",c[i]);
  592.                                         printf("\n\n");
  593.                                         break;
  594.                                 }
  595.                                 if(a[0]!=0&&b[0]==0)   // -+相减则将+变-再调加
  596.                                 {
  597.                                         b[0]='-'; // 将b的符号变为-
  598.                                         j=plus(a, b, c, m, n);  //加法运算
  599.                                         if(c[0]!=0)  
  600.                                                 printf("-");
  601.                                         for(i=1;i<j;i++)
  602.                                                 printf("%d",c[i]);
  603.                                         printf("\n\n");
  604.                                         break;
  605.                                 }
  606.                                 // --相减，将-变+再交换ab值,再调减
  607.                                 {
  608.                                         a[0]=0; // 将-变+
  609.                                         b[0]=0;
  610.                                         // 交换a，b数值
  611.                                         for(i=1; i<(m>n?m:n); i++)
  612.                                         {
  613.                                                 Temp[i]=a[i];
  614.                                                 a[i]=b[i];
  615.                                                 b[i]=Temp[i];
  616.                                         }
  617.                                         // 交换a，b位数
  618.                                         i=m;
  619.                                         m=n;
  620.                                         n=i;               
  621.                                         j=minus(a, b, c, m, n); //减法运算
  622.                                         if(c[0]!=0)  
  623.                                                 printf("-");
  624.                                         for(i=1;i<j;i++)
  625.                                                 printf("%d",c[i]);
  626.                                         printf("\n\n");
  627.                                         break;
  628.                                 }
  629.                         }                        
  630.                 case '3':
  631.                         {
  632.                                 if(a[1]==0||b[1]==0) // 任意个0相乘
  633.                                 {
  634.                                         printf("a*b=0\n\n");  
  635.                                         break;
  636.                                 }
  637.                                 printf("a*b=");
  638.                                 if((a[0]==0&&b[0]!=0)||(a[0]!=0&&b[0]==0)) // 异号相乘结果添'-'号，ab符号设为+，运算中符号不起作用
  639.                                         printf("-");
  640.                                 a[0]=0;
  641.                                 b[0]=0;
  642.                                 j=multi(a, b, c, m, n);  //正整数乘法运算
  643.                                 for(i=1;i<j;i++)
  644.                                         printf("%d",c[i]);
  645.                                 printf("\n\n");
  646.                                 break;
  647.                         }                        
  648.                 case '4':
  649.                         {
  650.                                 if(b[1]==0) // 除数为0
  651.                                 {
  652.                                         printf("输入错误!!\n除数不能为0!!!\n\n");  
  653.                                         break;
  654.                                 }
  655.                                 else if(a[1]==0) //被除数为0
  656.                                 {
  657.                                         printf("a÷b=0\n\n");
  658.                                         break;
  659.                                 }
  660.                                 printf("a÷b=");
  661.                                 if((a[0]==0&&b[0]!=0)||(a[0]!=0&&b[0]==0)) // 异号相除结果添'-'号，ab符号设为+，运算中符号不起作用
  662.                                         printf("-");
  663.                                 len = Division(a, b, c, m, n, &remainder, Temp);
  664.                                 //输出结果
  665.                                 if( len>0 )
  666.                                 {
  667.                                         for(i = 1; i < len; i++ )                                       
  668.                                                 printf("%d", c[i]);
  669.                                         if(remainder>0) // 有余数，输出余数
  670.                                         {
  671.                                                 printf("……");
  672.                                                 for(i=remainder-1; i>0; i--)
  673.                                                         printf("%d", Temp[i]);
  674.                                         }                                       
  675.                                 }
  676.                                 else
  677.                                 {
  678.                                         printf("0……");
  679.                                         for(i = 1; i < m; i++ )                                       
  680.                                                 printf("%d", a[i]);
  681.                                 }
  682.                                 printf("\n\n");        
  683.                                 break;
  684.                         }
  685.                 }
  686.         }
  687.         return 0;
  688. }
复制代码


大整数, C语言四则运算, 密码学

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:166089 发表于 2019-6-26 09:13 | 显示全部楼层
君任知命 发表于 2019-6-25 13:39
请问单片机该如何做大数运算？

你可以试试把这个程序移植进去，把最大位数先设置为10以下的进行测试，等该程序移植测试成功后，再把最大位数往上调。这个程序，除了输入输出函数和最大位数以外，其他的应该是与单片机内的程序无差别。
回复

使用道具 举报

ID:571663 发表于 2019-6-25 13:40 | 显示全部楼层
请问单片机该怎么进行大数运算？
回复

使用道具 举报

ID:571663 发表于 2019-6-25 13:39 | 显示全部楼层
请问单片机该如何做大数运算？
回复

使用道具 举报

ID:364211 发表于 2018-7-3 18:03 | 显示全部楼层
666666

评分

参与人数 1黑币 +5 收起 理由
啦啦啦一博 + 5

查看全部评分

回复

使用道具 举报

ID:1 发表于 2018-7-3 03:16 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表