高精度乘法

众所周知，由于整型数不能满足过大数的运算，所以，在进行过大数的乘法运算时需要运用一种新的方法------高精度乘法。
下面我将介绍大数相乘的几个步骤。

1.输入两个乘数，并定义后面需要到的变量

#include <stdio.h>
#include <string.h>
int main(void)
{
    char a[100],b[100];
    scanf("%s %s",&a,&b);
    int af[100],bf[100];
	int x=strlen(a);
	int y=strlen(b)

2.将字符数组中的数转移到整型数组中

	for(int i=0;i<x;i++)
	{
		af[i]=a[x-i-1]-'0';
		bf[i]=b[x-i-1]-'0';
	 }

3.我们再声明一个数组c来储存答案。大家通过一个简单的乘法运算进行模拟就可以看出，以同样的储存规则，a[0] * b[0] = c[0]; a[0] * b[1] + a[1] * b[0] = c[1];逐渐我们可以发现规律： "c[i + j] += a[i] * b[j]"同过一个循环去实现，就可以把c[i + j]计算出来。

 for(int i=0;i<x;i++)
	 {
	 	for(int j=0;j<y;j++)
	 	{
	 		c[i+j]=c[i+j]+af[i]*bf[j];
		 }
	 }

4.把c中的每一个都进位,最后输出。

	 int num=0;
	 int t;
	 while(c[t]!=0)
	 {
	 	t++;
	 }
	 for(int i=0;i<t;i++)
	 {
	 	num=c[i]+num;
	 	if(num>=10)
	 	{
	 		c[i]=num%10;
	 		num=num/10;
		 }
		 else
		 {
		 	c[i]=num;
		 	num=0;
		 }
		 
	 }
	 if(num!=0)
	 {
	 	c[t]=num;
	 		for(int i=t;i>=0;i--)
	 	{
	 		printf("%d",c[i]);
		 }
	 }
	 else
	 {
	 	for(int i=t-1;i>=0;i--)
	 	{
	 		printf("%d",c[i]);
		 }
	 }
	 
	 return 0;
}

#include<stdio.h>
#include<string.h>
int c[3000];
//两个数相乘，结果保存在数组c中
void chengfa(char numberN[150000],char numberM[150000]){
    int n = strlen(numberN), m = strlen(numberM);
    int a[n], b[m];
    int i, j;
    for (i = 0, j = n - 1; i < n; i++, j--) {
        a[i] = numberN[j] - '0';
    }
    for (i = 0, j = m - 1; i < m; i++, j--) {
        b[i] = numberM[j] - '0';
    }
    for (i = 0; i < 3000; i++) {
        c[i] = 0;
    }
    for (i = 0; i < n; i++) {
        for (j = 0; j < m; j++) {
            c[i + j] += a[i] * b[j];
        }
    }   
    for (i = 0; i < n + m; i++) {
        if (c[i] >= 10) {
            c[i + 1] += c[i] / 10;
            c[i] %= 10;
        }
    }
}
//输出数组c
void shuchu(){
	int i,j;
    for (j = 2999; j > 0; j--) {
        if (c[j] != 0)
        break;
    }
   	for (i = j; i >= 0; i--) {
   		printf("%d", c[i]);
   	}
}
int main() {
	char numberN[150000], numberM[150000];
    scanf("%s%s", numberN, numberM);
    chengfa(numberN, numberM);
    shuchu();
}

大一小白尝试C语言高精度乘法

一、高精度乘法是什么

高精度乘法就是对于普通数据类型无法表示的大整数进行乘法运算。

二、为什么需要高精度乘法

在C语言中，常用的数据类型有int, long long, double等，但是这些数据类型的大小有限，当输入的数据过大，这些数据类型就无法实现其功能，强行使用可能会出现错误。在这种情况下，我们需要高精度乘法来完成运算。

三、如何实现高精度乘法

为了更方便的理解高精度乘法，我们先从熟悉的竖式乘法开始。首先我们知道，电脑笨笨的，普通数据类型算不了大数乘法。但是小学的时候我们很聪明，学习了竖式乘法，表达是这样的。
过程是这样的，我们根据九九乘法表对于两位单独的数字进行运算，列在对应的位置上，最后进行累加并完成进位。

所以理论上来说，我们可以用竖式乘法计算很大的数。

四、实现

于是我们有了高精度乘法的实现思路：

1.输入

2.各位相乘相加

3.进位

4.输出

至于采取什么样的数据类型存储输入输出，答案显而易见，字符串是十分合适的。至此，我们有了大体的思路。那么就可以开始处理数据了。

首先是输入的一些准备工作，我们需要两个字符串来存储因数，以及一个字符串来存储答案，为了方便计算，我们将char的数转变为int类型。

void High_Precision_Multiplication(char c_number_1[], char c_number_2[], char c_answer[]) {
	int i_number_1[Number_Size];//第一个数字
	int i_number_2[Number_Size];//第二个数字
	int i_answer[Number_Size];//结果
	//可以在线处理
	int length_1 = strlen(c_number_1);//第一个数字的位数(长度)
	int length_2 = strlen(c_number_2);//第二个数字的位数(长度)
	int length_3;//答案的位数
	int i, j;
	char temp;//用于逆转
	memset(c_answer, 0, length_answer);
	memset(i_number_1, 0, sizeof(i_number_1));
	memset(i_number_2, 0, sizeof(i_number_2));
	memset(i_answer, 0, sizeof(i_answer));
	//完成初始化
}

逆转和数字转换

	for (i = 0; i < length_1; i++) {
		i_number_1[i] = c_number_1[length_1 - i - 1] - '0';
	}
	for (i = 0; i < length_2; i++) {
		i_number_2[i] = c_number_2[length_2 - i - 1] - '0';
	}
	//完成逆转+数字转换

竖式乘法

	for (i = 0; i < length_1; i++) {
		for (j = 0; j < length_2; j++) {
			i_answer[i + j] += i_number_1[i] * i_number_2[j];
		}
	}
	//完成相乘

根据竖式乘法的规则我们知道，上面代码的第三行是成立的。

进位

	for (i = 0; i < length_1 + length_2 - 1; i++) {
		if (i_answer[i] >= 10) {
			i_answer[i + 1] += i_answer[i] / 10;
			i_answer[i] %= 10;
		}
	}
	//完成进位

逆转和输出

为了方便输出，我们将答案转换回字符，并逆转头尾

	i = 0;
	while (i_answer[i] || i < length_1 + length_2 - 1) {
		i_answer[i] += '0';
		i++;
	}
	//转换回字符
	length_3 = i;
	i = 0;
	while (i < length_3 - i - 1) {
		temp = i_answer[i];;
		i_answer[i] = i_answer[length_3 - i - 1];
		i_answer[length_3 - i - 1] = temp;
		i++;
	}
	//逆转回去
	for (i = 0; i < length_3; i++) {
		c_answer[i] = i_answer[i];
	}
	//输出答案

五、最后的代码

将各部分代码合并，我们就得到了高精度乘法的函数

void High_Precision_Multiplication(char c_number_1[], char c_number_2[], char c_answer[], int length_answer) {
	int i_number_1[Number_Size];//第一个数字
	int i_number_2[Number_Size];//第二个数字
	int i_answer[Number_Size];//结果
	//可以在线处理
	int length_1 = strlen(c_number_1);//第一个数字的位数(长度)
	int length_2 = strlen(c_number_2);//第二个数字的位数(长度)
	int length_3;//答案的位数
	int i, j;
	char temp;//用于逆转
	memset(c_answer, 0, length_answer);
	memset(i_number_1, 0, sizeof(i_number_1));
	memset(i_number_2, 0, sizeof(i_number_2));
	memset(i_answer, 0, sizeof(i_answer));
	for (i = 0; i < length_1; i++) {
		i_number_1[i] = c_number_1[length_1 - i - 1] - '0';
	}
	for (i = 0; i < length_2; i++) {
		i_number_2[i] = c_number_2[length_2 - i - 1] - '0';
	}
	//完成逆转+数字转换
	for (i = 0; i < length_1; i++) {
		for (j = 0; j < length_2; j++) {
			i_answer[i + j] += i_number_1[i] * i_number_2[j];
		}
	}
	//完成相乘
	for (i = 0; i < length_1 + length_2 - 1; i++) {
		if (i_answer[i] >= 10) {
			i_answer[i + 1] += i_answer[i] / 10;
			i_answer[i] %= 10;
		}
	}
	//完成进位
	i = 0;
	while (i_answer[i] || i < length_1 + length_2 - 1) {
		i_answer[i] += '0';
		i++;
	}
	//转换回字符
	length_3 = i;
	i = 0;
	while (i < length_3 - i - 1) {
		temp = i_answer[i];;
		i_answer[i] = i_answer[length_3 - i - 1];
		i_answer[length_3 - i - 1] = temp;
		i++;
	}
	//逆转回去
	for (i = 0; i < length_3; i++) {
		c_answer[i] = i_answer[i];
	}
	//输出答案
	return;
}

六、结语

这个函数接受三个char*，并将前两个数字相乘，输出到第三个字符串中，但是该函数没有输入检测，也没有输出检测。而且这个函数占用了很多不必要的内存空间，为了步骤清晰，进行了很多不必要的分划，时间效率也不高。仍有大量可以优化的空间。

笔者是一位大一学生，因为手动实现高精度乘法的过程中出现了一些问题，因此写下这篇博客帮助理清思路。希望这篇博客能够帮助到更多刚接触C语言的同学们。如果文中有错误，欢迎指出。十分感谢各位的阅读！