前几天写的高精度的基本运算,包括整数和浮点数加减乘除,乘方和整数的阶乘.乘法和除法,以及乘方和阶乘都是以加法为基础,调用了加法的函数.写得很简陋,但是功能还可以,希望各位网友试用,如找到BUG请留言,谢谢!/*用数组存储数字，可以超越数据类型的限制，实现超长整型，高精度基本运算 */ #include<stdio.h>#include<stdlib.h>#include<string.h>#define MAX 200 int Compare(const char *a, const char *b);void IntAddition(char *augend, char *addend, char *sum);void IntSubtration(char *minuend, char *subtrahend, char *difference);void IntMultiplication(char *multiplicand, char *multiplier, char *product);void IntDivision(char *dividend, char *divisor, char *quotient, char *remainder);int  Radix(char *toStr, char *fromStr);void FloatAddition(char *augend, char *addend, char *sum);void FloatSubtration(char *minuend, char *subtrahend, char *difference);void FloatMultiplication(char *multiplicand, char *multiplier, char *product);void FloatDivision(char *dividend, char *divisor, char *quotient, int precision);void Insert(char s[], int left, int right);int IsCycle(char a[][MAX], int label);void Factorial(char *base, char *result); void IntPower(char *base, char *exponential, char *power);void FloatPower(char *base, char *exponential, char *power); int main(void){    char a[MAX] = {0};    char b[MAX] = {0};    char c[3*MAX] = {0};    char d[MAX] = {0};        puts("请输入第一个数：");    gets(a);    puts("请输入第二个数：");    gets(b);         IntAddition(a, b, c);    puts("两者之和：");    puts(c);        IntSubtration(a, b, c);    puts("两者之差：");    puts(c);        IntMultiplication(a, b, c);    puts("两者之积：");    puts(c);        IntDivision(a, b, c, d);    puts("两者之商：");    puts(c);    puts("余数：");    puts(d);  FloatAddition(a, b, c);  puts("两者之和：");   puts(c);      FloatSubtration(a, b, c);  puts("两者之差：");   puts(c);      FloatMultiplication(a, b, c);   puts("两者之积：");   puts(c);      FloatDivision(a, b, c, MAX);   puts("两者之商：");   puts(c);      IntPower(a, b, c);    puts("两者之乘方：");    puts(c);        FloatPower(a, b, c);    puts("两者之乘方：");    puts(c);        Factorial(a, c);    puts("a的阶乘：");    puts(c);       system("pause");   return 0;    }   /*函数功能：利用字符串实现超长整型，高精度加法运算 输入变量：char *augend，存储了被加数的字符串    char *addend，存储了加数的字符串    char *sum，用来存储两数之和的字符串 输出变量：char *sum，用来存储两数之和的字符串 返回值：  无 */void IntAddition(char *augend, char *addend, char *sum){ int cAug[MAX] = {0};//用来存储被加数的整型数组  int cAdd[MAX] = {0};//用来存储加数的整型数组  int cSum[MAX] = {0};//用来存储两数之和的整型数组  int lenAug = strlen(augend), lenAdd = strlen(addend);//被加数和加数字符串的长度  int lenMin = lenAug < lenAdd ? lenAug : lenAdd;//两个加数的长度中的较小值  int i;  //逆序复制加数和被加数到整型数组（因为加法运算是从低位开始）  for (i=0; i<lenAug; i++)  cAug[i] = augend[lenAug-1-i] - '0'; for (i=0; i<lenAdd; i++)  cAdd[i] = addend[lenAdd-1-i] - '0';   int carry = 0;//进位 int s = 0; //两数之和   for (i=0; i<lenMin; i++)//加法运算过程  {  s = cAug[i] + cAdd[i] + carry;//两个加数和进位之和作为当前位的和   cSum[i] = s % 10;//存储当前位   carry = s / 10;//获取进位  }  //处理加数或被加数超出长度lenMin的部分 while (i < lenAug) {  s = cAug[i] + carry;  cSum[i] = s % 10;  carry = s / 10;  i++; }  while (i < lenAdd) {  s = cAdd[i] + carry;  cSum[i] = s % 10;  carry = s / 10;  i++; }  if (carry > 0)//处理最后一个进位   cSum[i++] = carry;    int j; for (j=0; j<i; j++)//逆序存储两数之和到字符串sum   sum[j] = cSum[i-1-j] + '0'; sum[i] = '\0';} //比较两个用字符串存储的超长正整数的大小，若a>b，返回1；a==b，返回0；a<b，返回-1 int Compare(const char *a, const char *b){  int lenA = strlen(a); int lenB = strlen(b);  if (lenA != lenB)  return lenA > lenB ? 1 : -1; else  return strcmp(a, b);} /*函数功能：利用字符串实现超长整型，高精度减法运算 输入变量：char *minuend，存储了被减数的字符串    char *subtrahend，存储了减数的字符串    char *difference，用来存储两数之差的字符串 输出变量：char *difference，用来存储两数之差的字符串 返回值：  无 */void IntSubtration(char *minuend, char *subtrahend, char *difference){ if (strcmp(minuend, subtrahend) == 0)//如果两数相等，返回"0" {  strcpy(difference, "0");  return; }  int cM[MAX] = {0};//用来存储被减数的整型数组  int cS[MAX] = {0};//用来存储减数的整型数组  int cD[MAX] = {0};//用来存储两数之差的整型数组  int lenM = strlen(minuend), lenS = strlen(subtrahend);//被减数和减数字符串的长度  int lenMin = lenM < lenS ? lenM : lenS;//两个减数的长度中的较小值  int flag;//记录结果是整数还是负数  int i;  //逆序复制减数和被减数到整型数组（因为减法运算是从低位开始），保证cM大于cS  if (Compare(minuend, subtrahend) > 0) {  flag = 0;//被减数大于减数，结果为正数   for (i=0; i<lenM; i++)   cM[i] = minuend[lenM-1-i] - '0';  for (i=0; i<lenS; i++)   cS[i] = subtrahend[lenS-1-i] - '0'; } else {  flag = 1;//被减数小于减数，结果为负数，此时要用subtrahend - minuend  for (i=0; i<lenM; i++)   cS[i] = minuend[lenM-1-i] - '0';  for (i=0; i<lenS; i++)   cM[i] = subtrahend[lenS-1-i] - '0'; }  for (i=0; i<lenMin; i++)//减法运算过程  {  if (cM[i] >= cS[i])//被减数大于减数，直接相减    cD[i] = cM[i] - cS[i];  else //否则要向前借位   {   cD[i] = cM[i] + 10 - cS[i];   --cM[i+1];  } }  //处理减数或被减数超出长度lenMin的部分 int len = lenM > lenS ? lenM : lenS; while (i < len) {  if (cM[i] >= 0)   cD[i] = cM[i];  else   {   cD[i] = cM[i] + 10;   --cM[i+1];  }  i++; } while (cD[i-1] == 0)  i--;  int j = 0; if (flag == 1)//如果被减数小于减数，返回一个负数   difference[j++] = '-';   int k; for (k=i-1; k>=0; k--,j++)//逆序存储两数之差到字符串sum   difference[j] = cD[k] + '0'; difference[j] = '\0';} /*函数功能：利用字符串实现超长整型，高精度乘法运算 输入变量：char *minuend，存储了被乘数的字符串    char *subtrahend，存储了乘数的字符串    char *difference，用来存储两数之乘积的字符串 输出变量：char *difference，用来存储两数之乘积的字符串 返回值：  无 */void IntMultiplication(char *multiplicand, char *multiplier, char *product){ int cD[MAX] = {0};//用来存储被乘数的整型数组  int cR[MAX] = {0};//用来存储乘数的整型数组  int cP[MAX] = {0};//用来存储两数之乘积的整型数组  char tcP[MAX] = "";//用来存储两数之乘积的整型数组 int lenD = strlen(multiplicand), lenR = strlen(multiplier);//被乘数和乘数字符串的长度  int i, j, k;  //逆序复制乘数和被乘数到整型数组（因为乘法运算是从低位开始）  for (i=0; i<lenD; i++)  cD[i] = multiplicand[lenD-1-i] - '0'; for (i=0; i<lenR; i++)  cR[i] = multiplier[lenR-1-i] - '0';   int carry;//进位 int mul = 0; //两数之乘积   strcpy(product, "0"); //先使product的值为0  for (i=0; i<lenR; i++)//乘法运算过程  {  carry = 0;//进位  for (j=0; j<lenD; j++)//乘数的每一位都和被乘数进行乘法运算  {   mul = cD[j] * cR[i] + carry;//两个乘数之积与进位相加作为当前位乘积   cP[j] = mul % 10;//存储当前位    carry = mul / 10;//获取进位   }  if (carry > 0)//获取最后一个进位    cP[j++] = carry;    while (cP[j-1] == 0)//去掉多余的0    --j;      //逆序复制当前位的乘积tP到字符串tcP   for (k=0; k<j; k++)   tcP[k] = cP[j-1-k] + '0';  for (j=0; j<i; j++)//注意各位数得到的结果应相应左移    tcP[k++] = '0';  tcP[k] = '\0';    IntAddition(product, tcP, product);//对字符串进行加法运算  } } /*函数功能：利用字符串实现超长整型，高精度除法运算 输入变量：char *dividend，存储了被除数的字符串    char *divisor，存储了除数的字符串    char *quotient，用来存储两数相除之商的字符串     char *remainder，用来存储两数相除之余数的字符串 输出变量：char *quotient，用来存储两数相除之商的字符串     char *remainder，用来存储两数相除之余数的字符串返回值：  无 */void IntDivision(char *dividend, char *divisor, char *quotient, char *remainder){ if (Compare(dividend, divisor) == 0)//被除数等于除数  {  strcpy(quotient, "1");  strcpy(remainder, "0");  return ; } if (strcmp(divisor, "0") == 0 || Compare(dividend, divisor) < 0)//被除数小于除数  {  strcpy(quotient, "0");  strcpy(remainder, dividend);  return ; }  char buf[2] = "0";//临时数组依次存储被除数的每一位数  int i, s, k;  strcpy(remainder, ""); //先使product的值为空 for (i=0,k=0; dividend[i]!='\0'; i++) {  s = 0;  buf[0] = dividend[i];  strcat(remainder, buf);//接上被除数的一位数，改变当前余数   while (Compare(remainder, divisor) >= 0)//连减试商   {   s++;   IntSubtration(remainder, divisor, remainder);  }  quotient[k++] = s + '0';//记录每一位得到的商值   if (strcmp(remainder, "0") == 0)   strcpy(remainder, ""); //使product的值为空，去掉多余的0  } quotient[k] = '\0';  //去掉多余的0  int j; for (i=0; quotient[i]=='0'; i++)  ; for (j=i; j<=k; j++)  quotient[j-i] = quotient[j]; } /*函数功能：去掉原字符串的小数点，把浮点数转化成整数后存储到新的字符串 输入变量：char *toStr，存储了转化后的整数的字符串    char *fromStr，存储了原浮点数的字符串输出变量：char *toStr，存储了转化后的整数的字符串返回值：  原浮点数小数部分的长度 */int  Radix(char *toStr, char *fromStr) { int i = 0, j = 0; int len;  while (fromStr[i] != '.' && fromStr[i] != '\0') {  toStr[j++] = fromStr[i++]; } len = i++;//跳过小数点，并记录该位置  while (fromStr[i] != '\0') {  toStr[j++] = fromStr[i++]; }  return i - len - 1;//记录小数点后的数字个数 } /*函数功能：利用字符串实现超长浮点型，高精度加法运算 输入变量：char *augend，存储了被加数的字符串    char *addend，存储了加数的字符串    char *sum，用来存储两数之和的字符串 输出变量：char *sum，用来存储两数之和的字符串 返回值：  无 */void FloatAddition(char *augend, char *addend, char *sum){ char cAug[MAX] = {0};//用来存储被加数的字符串 char cAdd[MAX] = {0};//用来存储加数的字符串 char cSum[MAX] = {0};//用来存储两数之和的字符串 int lenAug, lenAdd, lenSum;//分别存储三个数的小数点后的数字个数  int i, topAug, topAdd;  //去掉小数点，把浮点数转化成整数后存储到新的字符串  lenAug = Radix(cAug, augend); lenAdd = Radix(cAdd, addend); topAug = strlen(cAug); topAdd = strlen(cAdd);  //在小数部分较短的字符串后补零，使得两个数的小数部分长度相等  if (lenAug > lenAdd) {  lenSum = lenAug;  for (i=lenAug-lenAdd; i>0; i--)   cAdd[topAdd++] = '0'; } else {  lenSum = lenAdd;  for (i=lenAdd-lenAug; i>0; i--)   cAug[topAug++] = '0'; } cAdd[topAdd++] = '\0'; cAug[topAug++] = '\0';  //执行整数加法运算  IntAddition(cAdd, cAug, cSum);  i = strlen(cSum) - 1; while (lenSum > 0 && cSum[i] == '0')//去掉小数部分多余的零  {  i--;  lenSum--; } cSum[i+2] = '\0';  while (lenSum > 0)//在适当位置插入'.’  {  cSum[i+1] = cSum[i];  i--;  lenSum--; } cSum[i+1] = '.';  strcpy(sum, cSum);} /*函数功能：利用字符串实现超长浮点型，高精度减法运算 输入变量：char *minuend，存储了被减数的字符串    char *subtrahend，存储了减数的字符串    char *difference，用来存储两数之差的字符串 输出变量：char *difference，用来存储两数之差的字符串 返回值：  无 */void FloatSubtration(char *minuend, char *subtrahend, char *difference){  if (strcmp(minuend, subtrahend) == 0)//如果两数相等，返回"0" {  strcpy(difference, "0");  return; } char cM[MAX] = {0};//用来存储被减数的字符串 char cS[MAX] = {0};//用来存储减数的字符串 char cD[MAX] = {0};//用来存储两数之差的字符串 int lenM, lenS, lenD;//分别存储三个数的小数点后的数字个数  int i, topM, topS;  //去掉小数点，把浮点数转化成整数后存储到新的字符串  lenM = Radix(cM, minuend); lenS = Radix(cS, subtrahend); topM = strlen(cM); topS = strlen(cS);  //在小数部分较短的字符串后补零，使得两个数的小数部分长度相等  if (lenM > lenS) {  lenD = lenM;  for (i=lenM-lenS; i>0; i--)   cS[topS++] = '0'; } else {  lenD = lenS;  for (i=lenS-lenM; i>0; i--)   cM[topM++] = '0'; } cM[topM++] = '\0'; cS[topS++] = '\0';  //执行整数减法运算  IntSubtration(cM, cS, cD);  i = strlen(cD) - 1; while (lenD > 0 && cD[i] == '0')//去掉小数部分多余的零  {  i--;  lenD--; } cD[i+2] = '\0';  while (lenD > 0)//在适当位置插入'.’  {  cD[i+1] = cD[i];  i--;  lenD--; } cD[i+1] = '.'; if (i == -1)//结果为0的情况  {  cD[0] = '0';  cD[1] = '.';  cD[2] = '\0'; }  strcpy(difference, cD);} /*函数功能：利用字符串实现超长浮点型，高精度乘法运算 输入变量：char *minuend，存储了被乘数的字符串    char *subtrahend，存储了乘数的字符串    char *difference，用来存储两数之乘积的字符串 输出变量：char *difference，用来存储两数之乘积的字符串 返回值：  无 */void FloatMultiplication(char *multiplicand, char *multiplier, char *product){ char cD[MAX] = {0};//用来存储被乘数的字符串 char cR[MAX] = {0};//用来存储乘数的字符串 char cP[2*MAX] = {0};//用来存储两数之乘积的字符串  int lenD, lenR, lenP;//分别存储三个数的小数点后的数字个数   //去掉小数点，把浮点数转化成整数后存储到新的字符串  lenD = Radix(cD, multiplicand); lenR = Radix(cR, multiplier); lenP = lenD + lenR;  IntMultiplication(cD, cR, cP);  int i = strlen(cP) - 1; while (lenP > 0 && cP[i] == '0')//去掉小数部分多余的零  {  i--;  lenP--; } cP[i+2] = '\0';  while (lenP > 0 && i >= 0)//在适当位置插入'.’  {  cP[i+1] = cP[i];  i--;  lenP--; } cP[i+1] = '.';  if (i == -1)//如果小数点在第一位，在前面添0  {  for (i=strlen(cP); i>0; --i)   cP[i+1+lenP] = cP[i];  for (i=0; i<lenP; ++i)   cP[i+2] = '0';  cP[1] = '.';  cP[0] = '0'; }  strcpy(product, cP);} /*函数功能：利用字符串实现超长浮点型，高精度除法运算 输入变量：char *dividend，存储了被除数的字符串    char *divisor，存储了除数的字符串    char *quotient，用来存储两数相除之商的字符串     int precision，用来存储小数部分的精度 输出变量：char *quotient，用来存储两数相除之商的字符串 返回值：  无 */void FloatDivision(char *dividend, char *divisor, char *quotient, int precision){ if (Compare(dividend, divisor) == 0)//被除数等于除数  {  strcpy(quotient, "1.");  return ; } if (strcmp(divisor, "0.")==0 || strcmp(divisor, "0")==0)//被除数小于除数  {  strcpy(quotient, "0.");  return ; }  char cD[MAX] = {0};//用来存储被除数的字符串 char cR[MAX] = {0};//用来存储除数的字符串 char cQ[MAX] = {0};//用来存储两数之商的字符串  char cY[MAX] = {0};//用来存储两数之当前余数的字符串  char tcY[MAX][MAX] = {0};//用来存储两数之所有余数的字符串  int lenD, lenR, lenQ;//分别存储三个数的小数点后的数字个数  int i, j, t, s, left;   //去掉小数点，把浮点数转化成整数后存储到新的字符串  lenD = Radix(cD, dividend); lenR = Radix(cR, divisor);  //如果被除数的小数部分长，则求出多出的小数长度，以便插入小数点，否则补0  if (lenD > lenR)  lenQ = lenD - lenR; else {  lenQ = 0;  i = strlen(cD);  for (j=0; j<lenR-lenD; j++)   cD[i++] = '0';  cD[i] = '\0';  }  IntDivision(cD, cR, cQ, cY);//得到整数部分的商   t = j = strlen(cQ); //插入小数点  for (i=0; i<lenQ; ++i,--t) {  if (t > 0)   cQ[t] = cQ[t-1];  else  {   t = 1;   cQ[t] = '0';  } }  cQ[t] = '.'; if (t == 0)//如果小数点在第一位，在前面添0  {  for (i=j++; i>=0; --i)   cQ[i+1] = cQ[i];  cQ[0] = '0'; } ++j;  //处理小数部分  i = t = 0; while (i < precision && strcmp(cY, "0")!=0) {  strcpy(tcY[t++], cY);//存储所有的余数（小数部分）   left = IsCycle(tcY, t-1);//判断是否出现循环节   if (left != t-1) //如果找到相等的余数，就结束循环        {                 Insert(cQ, j-(t-1-left), j);//在字符数组s中适当位置插入符号'('                             if (cQ[j-1] == '(' && cQ[j] == '0')//去除多余的循环节，即特殊处理可以除尽的情况                cQ[--j] = '\0';            else//否则用“（）”把循环节括起来             {             cQ[j+1] = ')';             cQ[j+2] = '\0';   }            break;        }    //否则继续计算小数部分    strcat(cY, "0");  s = 0;  if (Compare(cY, cR) < 0)   cQ[j++] = '0';  else  {   while (Compare(cY, cR) >= 0)   {    ++s;     IntSubtration(cY, cR, cY);   }   cQ[j++] = s + '0';  }  ++i; } if (i == precision)  cQ[j] = '\0';  strcpy(quotient, cQ);} /*函数介绍：在字符数组s中适当位置插入符号'('  char s[]： 字符数组，用来存储给定分数的小数形式  int left：数组a中需要插入符号'('的位置  int right：数组a中当前最右边的数字之后的下标 */ void Insert(char s[], int left, int right){ int i;    for (i=right; i>left; i--) //把数组元素后移，为插入符号'('腾出位置     {        s[i] = s[i-1];    }    s[left] = '(';//插入符号'('} /*函数介绍：判断当前余数是否与前面的某个余数相同，若相同，返回该余数的位置下标   char a[][MAX]： 字符数组，存储了当前余数   int label：当前余数的下标*/ int IsCycle(char a[][MAX], int label) { int i;    for (i=0; i<label; i++)    {        if (strcmp(a[i], a[label]) == 0) //如果数组中有与当前余数相同的余数，返回该余数的位置下标             return i;    }    return label; //否则返回当前余数的位置下标   } /*函数功能：利用字符串实现超长整型，高精度乘方运算 输入变量：char *base，存储了底数的字符串    char *exponential，存储了指数的字符串    char *power，用来存储两数相除之乘方的字符串 输出变量：char *power，用来存储两数相除之乘方的字符串返回值：  无 */void IntPower(char *base, char *exponential, char *power){ if (strcmp(exponential, "0") == 0)//如果指数为0，返回1  {  strcpy(power, "1");  return ; } if (strcmp(exponential, "1") == 0)//如果指数为1，返回底数 {  strcpy(power, base);  return ; }  char cRem[MAX] = {0};//用来存储余数的整型数组  char cExp[MAX] = {0};//用来存储指数的整型数组  char cPow[4*MAX] = {0};//用来存储两数之乘方的整型数组   IntDivision(exponential, "2", cExp, cRem);//将指数整除2  IntPower(base, cExp, cPow);//递归计算乘方，注意此时指数为原来的一半  IntMultiplication(cPow, cPow, power);//将递归得到的乘方结果相乘  if (strcmp(cRem, "1") == 0)//如果指数是奇数，乘方结果再乘以底数   IntMultiplication(power, base, power); } /*函数功能：利用字符串实现超长浮点型，高精度乘方运算，注意指数为整数 输入变量：char *base，存储了底数的字符串    char *exponential，存储了指数的字符串    char *power，用来存储两数相除之乘方的字符串 输出变量：char *power，用来存储两数相除之乘方的字符串返回值：  无 */void FloatPower(char *base, char *exponential, char *power){ if (strcmp(exponential, "0") == 0)//如果指数为0，返回1  {  strcpy(power, "1");  return ; } if (strcmp(exponential, "1") == 0)//如果指数为1，返回底数 {  strcpy(power, base);  return ; }  char cRem[MAX] = {0};//用来存储余数的整型数组  char cExp[MAX] = {0};//用来存储指数的整型数组  char cPow[4*MAX] = {0};//用来存储两数之乘方的整型数组   IntDivision(exponential, "2", cExp, cRem);//将指数整除2  FloatPower(base, cExp, cPow);//递归计算乘方，注意此时指数为原来的一半  FloatMultiplication(cPow, cPow, power);//将递归得到的乘方结果相乘  if (strcmp(cRem, "1") == 0)//如果指数是奇数，乘方结果再乘以底数   FloatMultiplication(power, base, power); } /*函数功能：利用字符串实现超长整型，高精度除法阶乘运算 输入变量：char *base，存储了被求阶乘的数的字符串    char *result，存储了阶乘结果的字符串输出变量：char *result，存储了阶乘结果的字符串返回值：  无 */void Factorial(char *base, char *result){ char cBase[MAX] = {0};//用来存储被求阶乘的数的整型数组   strcpy(cBase, base); strcpy(result, "1");  while (strcmp(cBase, "1") > 0) {  IntMultiplication(cBase, result, result);//按照阶乘的定义计算   IntSubtration(cBase, "1", cBase); }}

评论