大整数四则运算（加减乘除）C语言

最新推荐文章于 2024-04-15 03:15:56 发布
最新推荐文章于 2024-04-15 03:15:56 发布
阅读量4.9k 收藏 71
点赞数 6
文章标签： 数据结构 程序设计
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46077337/article/details/115309711
版权

大整数四则运算

数据结构课的作业，实现大整数的四则运算。

一、效果图
在这里插入图片描述

二、头函数

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
typedef struct BigNum{
	int num[1000];
	int carry[1000];
	int length;
}BigNum;

void AddNum(BigNum &Na,BigNum &Nb,BigNum &Nc);  //加法
void SubstractNum(BigNum &Na,BigNum &Nb,BigNum &Nc);  //减法
void MultiplyNum(BigNum &Na,BigNum &Nb,BigNum &Nc);  //乘法
void DivideNum(BigNum &Na,BigNum &Nb,BigNum &Nc);  //除法 
void Init(BigNum &N);  //初始化
void IntToChar(BigNum &N,char c[]);  //整型变字符型，最终输出时用到
 
int Compare(BigNum &Na,BigNum &Nb); //比较大小
void NegToPos(BigNum &N); //负数改为正数 
void PosToNeg(BigNum &N);//正数改为负数

三、测试程序

#include"BigNum.h"

int main(){
	BigNum Na,Nb,Nc;
	char a[1000],b[1000],c[1000];
	int i;
	int op;
	while(1){
		printf("请输入需要执行的操作:\n");
		printf("1.相加\n");
		printf("2.相减\n");		
		printf("3.相乘\n");
		printf("4.相除\n");
		printf("5.比较大小\n");
		printf("6.退出\n");
		scanf("%d",&op);
		if(op==6){
				printf("再见！\n");
				exit(0);
		}
		
		printf("请分别输入两个大整数Na和Nb:\n");
		scanf("%s",a);
		scanf("%s",b);
	
		for(i=0;a[i]!='\0';i++){
			Na.num[i]=a[i]-'0';	
		}
		Na.length=i;
		for(i=0;b[i]!='\0';i++){
			Nb.num[i]=b[i]-'0';		
		}	
		Nb.length=i;
		
		switch(op){
			case 1:{
				AddNum(Na,Nb,Nc);
				IntToChar(Nc,c);
				printf("%s\n",c);
				break;
			}
			case 2:{
				SubstractNum(Na,Nb,Nc);
				IntToChar(Nc,c);
				printf("%s\n",c);
				break;
			}
			case 3:{
				MultiplyNum(Na,Nb,Nc);
				IntToChar(Nc,c); 
				printf("%s\n",c);
				break;
			}
			case 4:{
				DivideNum(Na,Nb,Nc);
				IntToChar(Nc,c);
				printf("%s\n",c);
				break;
			}
			case 5:{
				int ans=Compare(Na,Nb);
				if(ans==1) printf("Na大\n"); 
				if(ans==0) printf("Na和Nb一样大\n"); 
				if(ans==-1) printf("Nb大\n"); 
				break;
			}
			case 6:{
				printf("再见！\n");
				exit(0);
			}
		}	
	} 

	return 0;
}

四、主函数

#include"BigNum.h"

void AddNum(BigNum &Na,BigNum &Nb,BigNum &Nc){   //加法 
	int ia=0,ib=0,ic=0;
	if(Na.num[0]!=-3&&Nb.num[0]!=-3){	//Na、Nb都为正数
		if(Compare(Na,Nb)==1||Compare(Na,Nb)==0){
			Nc.length=Na.length+1;	//Nc表长+1（考虑最长情况）
			Init(Nc);
			for(ia=Na.length-1,ib=Nb.length-1,ic=Nc.length-1;ib>=0;ia--,ib--,ic--){
				if(Na.num[ia]+Nb.num[ib]+Nc.carry[ic]>=10){
					Nc.carry[ic-1]=1;
					Nc.num[ic]=(Na.num[ia]+Nb.num[ib]+Nc.carry[ic])%10;
				}
				else{
					Nc.carry[ic-1]=0;
					Nc.num[ic]=Na.num[ia]+Nb.num[ib]+Nc.carry[ic];
				}
			}
			for(;ia>=0;ia--,ic--){	 //若Na有剩余数字，则将剩余数字加到Nc的前面
				if(Na.num[ia]+Nc.carry[ic]>=10){
					Nc.carry[ic-1]=1;
					Nc.num[ic]=(Na.num[ia]+Nc.carry[ic])%10;
				}
				else{
					Nc.carry[ic-1]=0;
					Nc.num[ic]=Na.num[ia]+Nc.carry[ic];
				}
			}
			
			if(Nc.carry[0]==0) {	//如果Nc第一位为0，则表长-1，元素左移一位
				Nc.length--;
				for(ic=0;ic<Nc.length;ic++){
					Nc.num[ic]=Nc.num[ic+1];
				}
			}
			else if(Nc.carry[0]==1){	//Nc第一位进位为1
				Nc.num[0]=Nc.carry[1];
			}
		}
		
		else if (Compare(Na,Nb)==-1){
			Nc.length=Nb.length+1;
			Init(Nc);
			for(ia=Na.length-1,ib=Nb.length-1,ic=Nc.length-1;ia>=0;ia--,ib--,ic--){
				if(Na.num[ia]+Nb.num[ib]+Nc.carry[ic]>=10){
					Nc.carry[ic-1]=1;
					Nc.num[ic]=(Na.num[ia]+Nb.num[ib]+Nc.carry[ic])%10;
				}
				else {
					Nc.carry[ic-1]=0;
					Nc.num[ic]=Na.num[ia]+Nb.num[ib]+Nc.carry[ic];
				}
			}
			for(;ib>=0;ib--,ic--){
				if(Nb.num[ib]+Nc.carry[ic]>=10){
					Nc.carry[ic-1]=1;
					Nc.num[ic]=(Nb.num[ib]+Nc.carry[ic])%10;
				}
				else{
					Nc.carry[ic-1]=0;
					Nc.num[ic]=Nb.num[ib]+Nc.carry[ic];
				}
			}
			
			if(Nc.carry[0]==0) {
				Nc.length--;
				for(ic=0;ic<Nc.length;ic++){
					Nc.num[ic]=Nc.num[ic+1];
				}
			}
			else if(Nc.carry[0]==1){
				Nc.num[0]=Nc.carry[1];
			}
		}
	}
	
	else if(Na.num[0]==-3&&Nb.num[0]==-3){	//Na、Nb同时为负
			NegToPos(Na);NegToPos(Nb);
			AddNum(Na,Nb,Nc);
			PosToNeg(Nc);
	}
	
	else if(Na.num[0]!=-3&&Nb.num[0]==-3){	//Na正，Nb负
		NegToPos(Nb);
		if(Compare(Na,Nb)==1||Compare(Na,Nb)==0){
			SubstractNum(Na,Nb,Nc);
		}
		else if(Compare(Na,Nb)==-1){
			SubstractNum(Nb,Na,Nc);
			PosToNeg(Nc);
		}
	}
	
	else if(Na.num[0]==-3&&Nb.num[0]!=-3){	//Na负，Nb正 
		NegToPos(Na);
		if(Compare(Na,Nb)==1||Compare(Na,Nb)==0){
			SubstractNum(Na,Nb,Nc);
			PosToNeg(Nc);
		}
		else if(Compare(Na,Nb)==-1){
			SubstractNum(Nb,Na,Nc);
		}
	}

}

void SubstractNum(BigNum &Na,BigNum &Nb,BigNum &Nc){   //减法 
	int ia=0,ib=0,ic=0;
	int flag=0;
	int Len_c;
	if(Na.num[0]!=-3&&Nb.num[0]!=-3){
		if(Compare(Na,Nb)==1||Compare(Na,Nb)==0){
			Nc.length=Na.length;
			Init(Nc);
			for(ia=Na.length-1,ib=Nb.length-1,ic=Nc.length-1;ib>=0;ia--,ib--,ic--){
				if(Na.num[ia]-Nb.num[ib]+Nc.carry[ic]<0){
					Nc.carry[ic-1]=-1;
					Nc.num[ic]=(Na.num[ia]+10-Nb.num[ib]+Nc.carry[ic])%10;
				}
				else{
					Nc.carry[ic-1]=0;
					Nc.num[ic]=Na.num[ia]-Nb.num[ib]+Nc.carry[ic];
				}
			}
			for(;ia>=0;ia--,ic--){
				if(Na.num[ia]+Nc.carry[ic]<0){
					Nc.carry[ic-1]=-1;
					Nc.num[ic]=(Na.num[ia]+10+Nc.carry[ic])%10;
				}
				else{
					Nc.carry[ic-1]=0;
					Nc.num[ic]=Na.num[ia]+Nc.carry[ic];
				}
			}
			Len_c=Nc.length;
			for(ic=0;Nc.num[ic]==0&&flag<Len_c-1;ic=0){	//将Nc首位为0的元素全部删除，直至首位为非0元素
					Nc.length--;
					flag++;
					for(int ic_=0;ic_<Nc.length;ic_++){
						Nc.num[ic_]=Nc.num[ic_+1];
					}
			}
			
		}
		else if(Compare(Na,Nb)==-1){
			Nc.length=Nb.length;
			SubstractNum(Nb,Na,Nc);
			PosToNeg(Nc);
		}
	}
	
	else if(Na.num[0]==-3&&Nb.num[0]==-3){
		if(Compare(Na,Nb)==1||Compare(Na,Nb)==0){
			NegToPos(Na);NegToPos(Nb);
			Nc.length=Nb.length;
			Init(Nc);
			SubstractNum(Nb,Na,Nc);
		}
		else if(Compare(Na,Nb)==-1){
			NegToPos(Na);NegToPos(Nb);
			Nc.length=Na.length;
			Init(Nc);		
			SubstractNum(Nb,Na,Nc);
		}
	}
	
	else if(Na.num[0]!=-3&&Nb.num[0]==-3){
		NegToPos(Nb);
		Nc.length=Na.length>Nb.length ? Na.length : Nb.length;
		Init(Nc);
		AddNum(Na,Nb,Nc);
	}
	
	else if(Na.num[0]==-3&&Nb.num[0]!=-3){
		NegToPos(Na);
		Nc.length=Na.length>Nb.length ? Na.length : Nb.length;
		Init(Nc);
		AddNum(Na,Nb,Nc);
		PosToNeg(Nc);
	}
}

void MultiplyNum(BigNum &Na,BigNum &Nb,BigNum &Nc){  //乘法 
//两次循环，外循环从Nb的个位开始向高位循环，内循环从Na的个位开始向高位循环，依次做乘法，保留进位。
	int ia=0,ib=0,ic=0;
	
	if(Na.num[0]==0&&Na.length==1||Nb.num[0]==0&&Nb.length==1){
		Init(Nc);
		Nc.length=1;
		Nc.num[0]=0;
	}
	else{
		if(Na.num[0]!=-3&&Nb.num[0]!=-3){
		if(Compare(Na,Nb)==1||Compare(Na,Nb)==0){
			Nc.length=Na.length*2;
			Init(Nc);
			int cnt=1; //cnt为外循环执行的次数 
			for(ib=Nb.length-1,ic=Nc.length-cnt;ib>=0;ib--,ic=Nc.length-cnt){
					Nc.carry[ic]=0; 
				for(ia=Na.length-1;ia>=0;ia--,ic--){
					if(Na.num[ia]*Nb.num[ib]+Nc.carry[ic]>=10){
						Nc.carry[ic-1]=(Na.num[ia]*Nb.num[ib]+Nc.carry[ic])/10;
						Nc.num[ic]+=(Na.num[ia]*Nb.num[ib]+Nc.carry[ic])%10;
					}
					else {
						Nc.carry[ic-1]=0;
						Nc.num[ic]+=Na.num[ia]*Nb.num[ib]+Nc.carry[ic];
					}
					if(Nc.num[ic]>=10) {
						Nc.num[ic-1] += Nc.num[ic]/10;
						Nc.num[ic] = Nc.num[ic]%10;
						
					}
				}
				Nc.num[ic]+=Nc.carry[ic];
				cnt++;
			}
		}
		else if(Compare(Na,Nb)==-1){
			MultiplyNum(Nb,Na,Nc);		
		}
		}
		else if(Na.num[0]==-3&&Nb.num[0]==-3){
			NegToPos(Na);NegToPos(Nb);
			MultiplyNum(Na,Nb,Nc);
		}
		else if(Na.num[0]!=-3&&Nb.num[0]==-3){
			NegToPos(Nb);
			MultiplyNum(Na,Nb,Nc);
			PosToNeg(Nc);
		}
		else if(Na.num[0]==-3&&Nb.num[0]!=-3){
			NegToPos(Na);
			MultiplyNum(Na,Nb,Nc);
			PosToNeg(Nc);
		}
		
		for(ic=0;Nc.num[ic]==0;ic=0){
			Nc.length--;
			for(int ic_=0;ic_<Nc.length;ic_++){
				Nc.num[ic_]=Nc.num[ic_+1];
			}
		}
	}	
}

void DivideNum(BigNum &Na,BigNum &Nb,BigNum &Nc){  //除法 
	int ia=0,ib=0,ic=0;
	int i,i_;
	int quotient;//商
	BigNum dividend,divisor; //被除数 ,除数
	BigNum current,Nd,answer;  
	Init(divisor);Init(dividend);
	Init(current);Init(Nd);
	dividend=Na; divisor=Nb;
	Nd.length=1;
	if(Na.num[0]!=-3&&Nb.num[0]!=-3){
		if(Compare(Na,Nb)==1||Compare(Na,Nb)==0){
			Nc.length=Na.length;
			current.length=Nb.length;
			for(ia=0;ia<Nb.length;ia++){
				current.num[ia] = Na.num[ia];			
			}
			if(Compare(current,Nb)==1||Compare(current,Nb)==0){
				Init(Nc);
				Nc.length=Na.length-Nb.length+1;
				dividend.length=Nb.length;
				while(ic!=Nc.length){
					for(quotient=1;quotient<=10;quotient++){
						Nd.num[0]=quotient;	
						MultiplyNum(Nd,Nb,answer);
						if(Compare(answer,current)==1){
							quotient--; break;
						}
						else if(Compare(answer,current)==0) break;
					}
					Nc.num[ic++]=quotient;
					Nd.num[0]=quotient;
					MultiplyNum(Nd,divisor,answer);
					SubstractNum(current,answer,dividend);
					if(dividend.length==Nb.length&&Nb.length!=1)	dividend.length=Nb.length+1;
					else  dividend.length=Nb.length;
					int flag=0;
					if(dividend.num[0]==0&&dividend.length==2) flag=1;
					for(i=0;dividend.num[i]==0&&ic!=Nc.length;i=0){	//将dividend首位为0的元素全部删除，直至首位为非0元素
						for(int i_=0;i_<dividend.length;i_++){
							dividend.num[i_]=dividend.num[i_+1];
						}
				
					}
					if(flag==1) dividend.length--;
					dividend.num[dividend.length-1]=Na.num[ia++];
					current=dividend; 
				} 
			} 
			else if(Compare(current,Nb)==-1){
				current.length=Nb.length+1;
				for(ia=0;ia<=Nb.length;ia++){
					current.num[ia] = Na.num[ia];			
				}
				Init(Nc);
				Nc.length=Na.length-Nb.length;
				dividend.length=Nb.length+1;
				while(ic!=Nc.length){
					for(quotient=1;quotient<=10;quotient++){
						Nd.num[0]=quotient;	
						MultiplyNum(Nd,Nb,answer);
						
						if(Compare(answer,current)==1){
							quotient--; break;
						}
						else if(Compare(answer,current)==0) break;
					}
					Nc.num[ic++]=quotient;
					Nd.num[0]=quotient;
					MultiplyNum(Nd,divisor,answer);
					SubstractNum(current,answer,dividend);
					if(dividend.num[0]!=0)	dividend.length=Nb.length+1;
					else dividend.length=Nb.length;
					dividend.num[dividend.length-1]=Na.num[ia++];
					current=dividend;
				}
			}
		}
	}
	else if(Na.num[0]==-3&&Nb.num[0]==-3){
		NegToPos(Na);NegToPos(Nb);
		DivideNum(Na,Nb,Nc);
	}
	
	else if(Na.num[0]!=-3&&Nb.num[0]==-3){
		NegToPos(Nb);
			DivideNum(Na,Nb,Nc);
		PosToNeg(Nc);
	}
	
	else if(Na.num[0]==-3&&Nb.num[0]!=-3){
		NegToPos(Na);
		DivideNum(Na,Nb,Nc);
		PosToNeg(Nc);
	}
}

	
void Init(BigNum &N){   //初始化 
	int i; 
	for(i=0;i<N.length;i++){
		N.num[i]=0;	
		N.carry[i]=0;
	}
}

void IntToChar(BigNum &N,char c[]){  //整型变字符型 ,最终输出时用到 
	int i;
	for(i=0;i<N.length;i++){
			c[i]=N.num[i]+'0';
	}
	c[i]='\0';
}


int Compare(BigNum &Na,BigNum &Nb){  //比较大小 
	if(Na.num[0]!=-3&&Nb.num[0]==-3) return 1;   //Na正,Nb负，则Na大  

	else if(Na.num[0]==-3&&Nb.num[0]!=-3) return -1;	 //Na负,Nb正，则Nb大  
	
	else if(Na.num[0]==-3&&Nb.num[0]==-3){	//Na、Nb同为负
		if(Na.length>Nb.length) return -1;
		else if(Na.length<Nb.length) return 1;
		else if(Na.length==Nb.length){
			for(int i=1;i<Na.length;i++){
				if(Na.num[i]<Nb.num[i]) return 1;
				else if(Na.num[i]>Nb.num[i]) return -1;
			}
			return 0;
		}
	}
	
	else if(Na.num[0]!=-3&&Nb.num[0]!=-3){	//Na、Nb同为正
		if(Na.length>Nb.length) return 1;
		else if(Na.length<Nb.length) return -1;
		else if(Na.length==Nb.length){
			for(int i=0;i<Na.length;i++){
				if(Na.num[i]<Nb.num[i]) return -1;
				else if(Na.num[i]>Nb.num[i]) return 1;
			}
			return 0;
		}
	}	
}

void NegToPos(BigNum &N){   //负数变正数 
	int i;
	N.length--;
	for(i=0;i<N.length;i++){
		N.num[i]=N.num[i+1];
	}
} 

void PosToNeg(BigNum &N){  //正数变负数 
	int i;
	N.length++;
	for(i=N.length-1;i>0;i--){
		N.num[i]=N.num[i-1];
	}
	N.num[0]=-3; 
}
什么也不会的四十二
关注
  • 6
    点赞
  • 踩
  • 71
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
c语言实现一种使用栈的整数加减乘除计算器
09-10
c语言实现的整数加减乘除运算，实现竖式表达，可以连续运算，采用栈的方式完成四则运算中的先乘除后加减。
c语言实现一种不使用栈的整数加减乘除计算器
09-10
c语言实现整数加减乘除的计算器，采用非栈的方式处理先乘除后加减的功能 。实现竖式输出，支持连续运算功能，
用双向循环链表实现长整数加减乘除（四则运算）——数据结构课程实践
m0_73704655的博客
11-08 1495
/ 定义链表节点结构int data;Node* next;Node* prev;私有部分private:Node* head;// 头结点// 符号位公有部分：BigInt构造函数public:BigInt() {判断长正数是否为0//判断是否为0在链表尾部插入数据// 在链表尾部插入数据移除链表开头多余的零值节点// 移动到第一个非零节点插入数据到链表头部// 插入数据到链表头部。
【大整数四则运算】
weixin_30468137的博客
01-04 374
定义并实现超长整数类double long，要求如下： 64位数据长度，有符号 支持＋、－、＊、／运算 支持＋＝、－＝、／＝运算 支持cin>>和cout<<操作 首先，我们的运算对象是大整数并且要支持cout<<和cin>>操作，数组和链表是可选择项。在这里我们用数组。数组有int型和char型，选哪个好呢？只能选cha...
C语言实现大数运算（长整数的加、减、乘、除）_c语言顺序结构 整数的加减乘除
最新发布
2401_84247617的博客
04-15 1043
4、除法：如果被除数大于被除数，先保持除数和被除数位数相同，然后被除数一次次减去除数，最终得到在此位之下被除数对于除数的倍数，改变位数，得到其他位数下的倍数，最终得到结果。3、乘法：取其中任意一个数，分别用此数各位中数字与另一个数字相乘，各个位置相乘的结果重叠部分相加，最终考虑进位关系。2、减法：比较好两数大小，大数减去小数，两数末尾对齐，自末端逐个相减，减不掉就向高位借一。(img-K2mIsz6h-1713122138502)]//如果发现被减数小于减数，则重新计算，用减数减去被减数，输出负号。
Python：整数四则运算及格式化输出
潮汐未见潮落的博客
09-17 9155
Python：整数四则运算及格式化输出
数据结构：整数简易四则运算（类实现）
qq_51264201的博客
04-18 716
c++创建类来实现整数的四则运算，并在文件中输出保存。
C语言-大整数四则运算
热门推荐
莫等闲
04-17 2万+
int的存储空间有限，利用”串”的结构，分享一则“大整数”简单四则运算。
1003: 两个整数的四则运算 C语言
指尖跳动的字节的博客
09-01 8448
1003: 两个整数的四则运算 时间限制: 1 Sec 内存限制: 30 MB 提交: 58893 解决: 32171 [状态] [讨论版] [提交] [命题人:admin] 题目描述 输入两个整数num1和num2，请你设计一个程序，计算并输出它们的和、差、积、整数商及余数。 输入 输入只有两个正整数num1、num2。 输出 输出占一行，包括两个数的和、差、积、商及余数，数据之间用一个空格隔开。 样例输入 Copy 1 2 样例输出 Copy 3 -1 2 0 1 #include <stdi
汇编实现一位十进制加减乘除四则运算的计算器
10-14
汇编实现一位十进制加减乘除四则运算的计算器，代码简单易懂
非负整数高精度加减乘除运算
12-20
本程序实现两个非负整数的加减乘除四则高精度运算； 有比较详细的注释，测试了10组随机数据并未出现运行时错误。 如果发现程序有bug，欢迎提出指正！
用c语言实现超长整数的四则运算
03-22
在编程计算时, 程序设计语言本身的计算精度能满足一般问题的精度要求, 但对于计算精度要求较高 的一些特殊问题, 如计算100 阶乘的精确值, 用普通编程方法不能满足精度要求, 必须采用特殊的编程方 法。本文把计算机原理中的数值运算方法应用于高级语言编程, 总结出了一个提高计算精度的有效方法, 叫做分段运算法, 如不考虑机器的运行时间和内存容量, 采用这种方法可以使计算精度达到任意位。
C语言大整数的加减法运算
09-18
大整数的加减法运算
C++大整数运算
08-14
C++关于大整数类的相关运算包括重载加减乘除，赋值，输出和比较运算
c语言，实现带括号的四则运算的程序(使用Visual Studio )
08-16
首先，我们需要理解四则运算的规则，即加法(+)、减法(-)、乘法(*)和除法(/)，其中乘除优先于加减，而括号内的表达式优先级最高。这需要我们构建一个解析器来识别输入的数学表达式。 1. **字符串处理**：程序从用户...
C++.实现简易的四则运算计算器
weixin_51871724的博客
03-15 9239
文章目录C++.简易计算器的实现1 前言1.1 知识点2 实现流程2.1 简单的流程图2.2 主要函数2.3 其它注意点为什么使用vector存储后缀表达式？3 代码分析3.1 头文件head.h3.2 函数实现 head.cpp4 运行截图5 总结 C++.简易计算器的实现 1 前言 为了巩固自己的C++知识点，写了一个简易的四则运算计算器。尤其多用到了一些简单的数据结构与STL标准库的模板。 1.1 知识点 vector、string、map、stack的使用 中缀表达式转后缀表达式 对后缀表达式的计
（数据结构&C语言）实现简易四则运算
XY_Mckevince的博客
10-07 574
这篇文章介绍多项四则混合运算表达式的算法，用于之后仿写iOS计算器App。混合运算需要注意很多问题，尤其是算数的优先级，如果输入进来一串表达式字符串，我们应该如何处理这段字符串从而算出答案呢？主要在与理解，中缀转后缀、后缀的计算这些算法过程，尤其注意表达式合法性的判断。
C语言实现大数整数乘法
u012566910的专栏
10-25 643
#include #include #include char * bigmuilty(char*muiltied,int len1,char *muilty,int len2)//muiltied 为被乘数，len1为其长。muilty为乘数，len2为其长 { int len; int i=0; int j=0; int k=0; int
c语言高质量大整数四则运算,大整数的四则运算 高质量C语言程序_图文.doc
weixin_42333009的博客
05-24 351
设计题目： 大整数的四则运算1. 功能简介：编写出实现大整数之间相加，相减，相乘，相除的程序，并输出计算结构。课程设计要求：采用模块化程序设计源程序中应有足够的注释必须上机调试通过注重算法运用，优化存储效率与运算效率需提交源程序(含有注释)及相关文件(数据或数据库文件)；提交设计报告书。总体结构：数据初始化数据初始化判断运算符号加法正整数非正整数转变为正整数减法转变为加法乘法除法转变为...
c语言如何实现超长整数四则运算(加减乘除)
12-27
C语言可以实现超长整数四则运算，主要需要以字符串的形式存储超长整数，然后通过代码逐位进行运算。 首先，需要将超长整数以字符串的形式存储，例如可以使用char数组来表示超长整数，然后将每一位数字存储在数组中，最高位在数组的最前面。 其次，要实现超长整数的加减乘除运算，可以通过模拟手工计算的方式，逐位进行运算。对于加法和减法，从最低位开始逐位进行计算，并处理进位和借位的情况；对于乘法，采用类似手工乘法的方式，逐位相乘并处理进位；对于除法，可以采用长除法的方式进行计算。 在进行运算时，需要注意超长整数的溢出问题，以及结果的符号处理。此外，需要考虑优化算法，提高运算效率，比如通过去除前导零、优化乘法算法等。 总之，通过将超长整数以字符串形式存储，并通过逐位计算的方式实现四则运算，可以在C语言中实现超长整数的运算。在实际开发中，可以借助现有的大整数库，如GMP库等，来方便地实现超长整数的计算。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值