《数据结构大数相乘_小学教育-小学课件》由会员分享，可在线阅读，更多相关《数据结构大数相乘_小学教育-小学课件（49页珍藏版）》请在金锄头文库上搜索。
1、v . . . . . . 资 料. . 课题名称：大数相乘 1.问题描述 计算机的内存有限，而且各个函数类型的范围有限，如果要计算两个更大的乘数， 就会超出范围， 得到不精确的数， 如何得到更精确的数，而又不受计算机内存空间的限制，本程序就可以解决大数相乘的问题。 2.设计思路 这个程序的关键是如何保存大数的各个数字， 以及如何处理大数乘法的进位问题。本人是运用栈的思想做的，先定义一个整型的栈，大数传入栈的整型数组中，在乘法运算函数中，先从一个栈中取出一个大数 S1的个位上的数字 a，再从另一个大数 S2 取出一个个位数字 b,再将 a*b+d(d 为进位数)的个位数字压到栈 S中，十位上进
2、位的数字先保存到 d 中，再从 S2 中取出一个十位数，与 a 相乘，得到的个位数字再压到栈 S中，再从 S2 中取出一个数字，以此类推，直到 S2 中的数字被 a 乘完，得到一个新的大数 S，将该栈保存到 A 栈中，将 S销毁，再从 S1中取出大数的十位数字，与 S2 的各个数字相乘，得到一个新的大数压到 S中，将 S保存到 B 中，将 B 移位处理后，然后与 A相加得到另一个大数，以此类推，最终可相加得到想要的结果。这其中还用到了大数相加的原理。 v . . . . . . 资 料. . 3.数据结构设计 前面提到，要用到栈的操作，这里，由于一个大数的最大长度是一定的，且大数最多执行的操作
3、是插入和删除操作，所以顺序存储结构可以带来更大益处。为了便于大数相加，将大数的各个数字存入到整型数组中。 #define MAXSIZE 100 typedef struct node int dataMAXSIZE; int top; SeqStack,*PSeqStack; 4.功能函数设计 (1)栈初始化函数 Init_SeqStack(char *ch) 此函数是将传入的字符处理成 09 的整数存入整型数组中。将*ch- 0转化为整数存入 S-datai 中，结束标志是*ch 不等于0 (2) 首尾倒置函数 Convert_SeqStack(PSeqStack A) 此函数是将栈中的数
4、值首尾颠倒， 比如以前是 1234， 现在变成 4321。只要将传入的 A 的栈中的元素依次取出压到 C 中,再返回 C 栈即可 (3) 大数相加函数 Add(PSeqStack S1,PSeqStack S2) 此函数是处理两个大数相加的功能。将传入的两个大数压到 S1和 S2中，当 S1或 S2 不为空时，从 S1中取出 a,从 S2 中取出 b,得到范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压
5、到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . Result=(a+b)%10+d,其中初始时 d=0 ，再判断 Result 是否大于 10，如果小于 10 直接压到栈 S中，如果大于 10 将 Result%10 压入栈中，令 d=(a+
6、b)/10+Result/10;如果运算后其中的一个栈空了，另一个不空的栈的数值加上进位数d 再直接压到S中， 这样可以得到一个大数。 (4) 移位函数 Crol(PSeqStack S,int n) 将其中一位大数取出一位数字与另一位大数相乘的结果移位， 然后相加，从各位开始，每乘一个数，都要移位一个 0 (5) 复制函数 Copy_SeqStack(PSeqStack A,PSeqStack B) 将一个 A 栈中的元素拷贝到 B 栈中，先将 A 中的元素压到 C 栈中，再将 C 栈中的元素压到 B 栈中，即可实现复制功能 (6) 大数相乘函数 Multiply(PSeqStack S1,
7、PSeqStack S2) 此函数是实现大数相乘的核心算法。主要思想就是将 S1中取出个位数 a， 分别与 S2 中的各个数相乘得到新的大数， 再取 S1中的十位数，与 S1大数相乘，以此类推，然后将各个大数进行移位处理再相加 5.编码实现 #include stdafx.h #include stdlib.h #include stdio.h #include string.h #define MAXSIZE 100 typedef struct node 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个
8、数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . int dataMAXSIZE; int top; SeqStack,*PSeqStac
9、k; void Destroy_SeqStack(PSeqStack *S) if(*S) free(*S); *S=NULL; return; int Push_SeqStack(PSeqStack S,int x) if(S-top=MAXSIZE-1) return 0; else S-top+; S-dataS-top=x; return 1; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到
10、栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . PSeqStack Init_SeqStack(char *ch) PSeqStack S; int i=0; char *head; S=(PSeqStack)malloc(sizeof(Seq
11、Stack); if(S) S-top=-1; head=ch; while(*ch!=0) if(*head=-) S-datai=(*(+ch)-0)*(-1); else S-datai=*ch-0; ch+; S-top+; i+; return S; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个
12、数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . int GetTop_SeqStack(PSeqStack S,int *x) if(S-top=-1) return 0; else *x=S-dataS-top; return 1; int Empty_SeqStack(PSeqStack S) if(S-top=-1) return
13、 1; else return 0; int Pop_SeqStack(PSeqStack S,int *x) 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构
14、设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . if(Empty_SeqStack(S) return 0; else *x=S-dataS-top; S-top-; return 1; void print(PSeqStack S) int i; for(i=0;itop;i+) printf(%d,S-datai); /将栈顶变成栈尾，栈尾变成栈顶 PSeqStack Convert_SeqStack(PSeqStack A) int x; 范围得到不精确的数如何得到更精确的数而
15、又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资
16、料. . PSeqStack C; C=(PSeqStack)malloc(sizeof(SeqStack); if(C) C-top=-1; while(!Empty_SeqStack(A) Pop_SeqStack(A,&x); Push_SeqStack(C,x); return C; PSeqStack Add(PSeqStack S1,PSeqStack S2) PSeqStack S; int d=0,a,b,Result; S=(PSeqStack)malloc(sizeof(SeqStack); if(S) S-top=-1; while(!Empty_SeqStack(S1)
17、&!Empty_SeqStack(S2) Pop_SeqStack(S1,&a); 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这
18、里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . Pop_SeqStack(S2,&b); Result=(a+b)%10+d; /判断 Result 是否大于等于 10 if(Result/10=0) Push_SeqStack(S,Result); d=(a+b)/10; else if(Result/100) Push_SeqStack(S,Result%10); d=(a+b)/10+Result/10; while(!Empty_SeqStack(S1) Pop_SeqStack(S1,&a); Res
19、ult=a%10+d; if(Result/10=0) Push_SeqStack(S,Result); d=a/10; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资
20、料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . else Push_SeqStack(S,Result%10); d=a/10+Result/10; while(!Empty_SeqStack(S2) Pop_SeqStack(S2,&a); Result=a%10+d; if(Result/10=0) Push_SeqStack(S,Result); d=a/10; else Push_SeqStack(S,Result%10); d=a/10+Result/10; 范围
21、得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以
22、带v . . . . . . 资 料. . if(d!=0) Push_SeqStack(S,1); S=Convert_SeqStack(S); return S; PSeqStack Crol(PSeqStack S,int n) int i; for(i=0;itop=-1; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再
23、压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . while(!Empty_SeqStack(A) Pop_SeqStack(A,&x); Push_SeqStack(C,x); while(!Empty_SeqStack(B) Pop_SeqStack(B,&x); while(!Empty_SeqStack(C)
24、 Pop_SeqStack(C,&x); Push_SeqStack(A,x); Push_SeqStack(B,x); PSeqStack Multiply(PSeqStack S1,PSeqStack S2) PSeqStack S,A,B; int a,b,c,d=0,Result,i,count=0; S=(PSeqStack)malloc(sizeof(SeqStack); 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个
25、位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . if(S) S-top=-1; A=(PSeqStack)malloc(sizeof(SeqStack); if(A) A-top=-1; B=(PSeqStack
26、)malloc(sizeof(SeqStack); if(B) B-top=-1; while(!Empty_SeqStack(S1) Pop_SeqStack(S1,&a); d=0; for(i=S2-top;i-1;i-) b=S2-datai; /printf(%d,b); Result=a*b%10+d; if(Result/10=0) Push_SeqStack(S,Result); d=a*b/10; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用
27、栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . else if(Result/100) Push_SeqStack(S,Result%10); d=a*b/10+Result/10
28、; if(d!=0) Push_SeqStack(S,d); /printf(nS 为：); /print(S); S=Convert_SeqStack(S); if(count=0) Copy_SeqStack(S,A);/将 S栈拷贝到 A 栈 /printf(nA为：); /print(A); else B=Crol(S,count);/将 B 左移 count 位 /printf(nB为：); /print(B); 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本
29、人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . A=Add(A,B); /printf(nA为：); /print(A); count+; Destroy_SeqStack
30、(&S); S=(PSeqStack)malloc(sizeof(SeqStack); if(S) S-top=-1; A=Convert_SeqStack(A); while(GetTop_SeqStack(A,&c)&c=0) Pop_SeqStack(A,&c); if(Empty_SeqStack(A) Push_SeqStack(A,0); A=Convert_SeqStack(A); return A; void main() PSeqStack A,B,C; int i; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程
31、序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . /char *ch1=29,*ch2=896; /char
32、*ch1=99,*ch2=1; /char *ch1=1111,*ch2=1111; /char *ch1=11111111,*ch2=-11111111; /char *ch1=464,*ch2=0; char ch150,ch250; system(color 70); printf( 请输入第一个大数：); gets(ch1); printf(n 请输入第二个大数：); gets(ch2); printf( 该乘式为：); A=Init_SeqStack(ch1); print(A); printf(*); B=Init_SeqStack(ch2); print(B); printf(n
33、); /C=Add(A,B); C=Multiply(A,B); printf(n 计算结果为：); for(i=0;itop;i+) 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大
34、数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . printf(%d,C-datai); / print(C); printf(n); /printf( 实际结果为：225); 6.运行与测试 首先屏幕会提示你输入第一个大数，然后按回车键，屏幕会提示你输入第二个大数，再按回车键，即可得到计算结果 7.设计中存在的问题及感想 本程序的缺陷对负数以及小数相乘没有处理好，只能处理大的整数，这是一个遗憾。 其实这个大数相乘程序我是根据大数相加的思想来做的，大数相加的进位
35、思想是加进位，而大数相乘是乘进位，我想这是一样的原理。大数相加时，进位数不超过 1，而两个一位数相乘得到的进位数不超过 8 所以进位数都控制在一位数以内，这就不太复杂了。不过本程序还有一个问题，就是计算效率不高，虽然测试的时间不慢，但是我当测试 100000 个数时，其效率可见明显降低。本来想范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的
36、个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . 用傅里叶算法的，可是傅里叶算法思想没看懂，所以用了自己的本方法。 课题名称：模拟计算器 1.问题描述 如果让我们计算4+2*(8-5)-4/2=? 我们该怎么计算？为了实现这个功能，特地做了这个计算器，可以对包含加、减、乘、除的运算符的任意整型式进行求解。
37、2.设计思路 这个程序的关键就是如何将输入的中缀表达式转化为后缀表达式， 然后再对后缀表达式进行求值运算。对于中缀表达式转为后缀表达式，在参数先定义两个指针型字符串 infixexp 和 postfixexp ，infixexp 是传入的中缀表达式字符串，postfixexp 是传出的后缀表达式字符串，再定义一个栈，当栈顶元素不等于#时，然后判断 infixexp 中的每一个字符是不是数，如果是数，传入 postfiexp 中，否则进一步判断 w 是不是),若不是判断栈顶元素的优先级，将操作符压入栈中，以此类推，最终得到后缀表达式。对于后缀表达式的运算，主要判断是不是数字还是操作符，如果是数字
38、压到栈中，如果是操作符，从栈中取出两个数字运算。 本人对于本程序还设计了一个操作界面，用的是 MFC 语言设计的，操作界面主要有一个文本框和 19 个按钮组成，有清零按钮，删除按钮，加减乘除按钮，以及各个操作数按钮，= 按钮，这些按钮大范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被
39、乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . 部分都是传入相应的字符串到文本框中，当按下= 号按钮时，再从文本框中得到字符串，对字符串进行处理，然后运算出结果。 3.数据结构设计 主要建立了一个 CCaculatordlg的类，该类继承 MFC 中 CDialog 的特征，这样可以在 MFC 中建立一个单文档对话框，这个对话框可以添加一些控件来做成一个计算器界
40、面，如何对于该计算器操作，就要看控制各个控件函数怎么实现的。这里的类如下： class CCaculatorDlg : public CDialog / Construction public: int postfix_exp(char *A); int infix_exp_value(char *infixexp,char *postfixexp); int priority(char op); int IsNum(char c); /int infix_exp_value(char *infix,char *postfixexp); double num; /char CalculateE
41、xpre; /double CalculateResult; /double CalculateNum; char ch50,ch110,ch210,op; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要
42、的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . char text50; /stack S; CCaculatorDlg(CWnd* pParent = NULL); / standard constructor / Dialog Data /AFX_DATA(CCaculatorDlg) enum IDD = IDD_CACULATOR ; / NOTE: the ClassWizard will add data members he
43、re /AFX_DATA / Overrides / ClassWizard generated virtual function overrides /AFX_VIRTUAL(CCaculatorDlg) protected: virtual void DoDataExchange(CDataExchange* pDX); / DDX/DDV support /AFX_VIRTUAL / Implementation protected: 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大
44、数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . / Generated message map functions /AFX_MSG(CCaculator
45、Dlg) afx_msg void OnAdd(); afx_msg void OnBtn1(); afx_msg void OnBtn0(); afx_msg void OnBtn2(); afx_msg void OnBtn3(); afx_msg void OnBtn4(); afx_msg void OnBtn5(); afx_msg void OnBtn6(); afx_msg void OnBtn7(); afx_msg void OnBtn8(); afx_msg void OnBtn9(); afx_msg void OnClear(); afx_msg void OnDivi
46、de(); afx_msg void OnEquals(); afx_msg void OnMinus(); afx_msg void OnMultiply(); afx_msg void OnReset(); virtual BOOL OnInitDialog(); afx_msg void OnRbrackets(); afx_msg void OnLbrackets(); 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字
47、再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . /AFX_MSG DECLARE_MESSAGE_MAP() ; 4.功能函数设计 (1)按键 0 函数 CCaculatorDlg:OnBtn0( ) 先得到文本框字符
48、串，然后将该字符串末尾处加 0，再将所有的字符串显示到文本框中 (2) 按键 1函数 CCaculatorDlg:OnBtn1( ) 先得到文本框字符串，然后将该字符串末尾处加 1，再将所有的字符串显示到文本框中 (3) 按键 2 函数 CCaculatorDlg:OnBtn2( ) 先得到文本框字符串，然后将该字符串末尾处加 2，再将所有的字符串显示到文本框中 (4) 按键 3 函数 CCaculatorDlg:OnBtn3( ) 先得到文本框字符串，然后将该字符串末尾处加 3，再将所有的字符串显示到文本框中 (5) 按键 4 函数 CCaculatorDlg:OnBtn4( ) 先得到文本
49、框字符串，然后将该字符串末尾处加 4，再将所有的字符串显示到文本框中 (6) 按键 5 函数 CCaculatorDlg:OnBtn5( ) 先得到文本框字符串，然后将该字符串末尾处加 5，再将所有的字符串显示到文本框中 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新
50、的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . (7) 按键 6 函数 CCaculatorDlg:OnBtn6( ) 先得到文本框字符串，然后将该字符串末尾处加 6，再将所有的字符串显示到文本框中 (8) 按键 7 函数 CCaculatorDlg:OnBtn7( ) 先得到文本框字符串，然后将该字符串末尾处加 7，再将所有的字符串显示到文本框中 (9) 按键 8 函数 C
51、CaculatorDlg:OnBtn8( ) 先得到文本框字符串，然后将该字符串末尾处加 8，再将所有的字符串显示到文本框中 (10)按键 9 函数 CCaculatorDlg:OnBtn9( ) 先得到文本框字符串，然后将该字符串末尾处加 9，再将所有的字符串显示到文本框中 (11)按键加函数 CCaculatorDlg:OnAdd( ) 先得到文本框字符串，然后将该字符串末尾处加+字符，再将所有的字符串显示到文本框中 (12)按键减函数 CCaculatorDlg:OnMinus( ) 先得到文本框字符串，然后将该字符串末尾处加- 字符，再将所有的字符串显示到文本框中 (13)按键乘函数
52、CCaculatorDlg:OnMultiply( ) 先得到文本框字符串，然后将该字符串末尾处加*，再将所有的字符串显示到文本框中 (14)按键除函数 CCaculatorDlg:OnDivide( ) 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存
53、到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . 先得到文本框字符串，然后将该字符串末尾处加，再将所有的字符串显示到文本框中 (15)按键清除函数 CCaculatorDlg:OnClear( ) 先得到文本框字符串，然后将该字符串的最后一个字符删除，再将所有的字符串显示到文本框中 (16)按键左括号函数 CCaculatorDlg:OnRbrackets() 先得到文本框字符串，然后将该字符
54、串末尾处加（，再将所有的字符串显示到文本框中 (17)按键又括号函数 CCaculatorDlg:OnLbrackets() 先得到文本框字符串，然后将该字符串末尾处加），再将所有的字符串显示到文本框中 (18)按键左括号函数 CCaculatorDlg:OnReset() 将文本框中的字符串清零 (19)判断是否是数字 CCaculatorDlg:IsNum(char c) 如果传入的字符在 09 范围内则是数字 (20) 优先级函数 CCaculatorDlg:priority(char op1) 根据传入的字符判断优先级 (21)将中缀表达式转为后缀表达式CCaculatorDlg:in
55、fix_exp_value(char *infixexp, char *postfixexp) Infixexp 是传入的中缀表达式， 即从文本框得到的字符， 而 postfixexp是后缀表达式，将要传出去的字符串 (22) 计算后缀表达式的值 postfix_exp(char *A) 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位
56、数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . 将转化后的后缀表达式的字符串，传入该函数中，可以运算出结果 (23) 按键等于函数 CCaculatorDlg:OnEquals() 先从文本框中得到字符串，再将字符串通过 infix_exp_value转华为后缀表达式，再通过 postfix_exp 转化为数
57、值，将计算所得的数值转化为字符显示到文本框中。 5.编码实现 #include stdafx.h #include Chess.h #include CaculatorDlg.h #include math.h #include using namespace std; #ifdef _DEBUG #define new DEBUG_NEW #undef THIS_FILE static char THIS_FILE = _FILE_; #endif / / CCaculatorDlg dialog CCaculatorDlg:CCaculatorDlg(CWnd* pParent /*=NU
58、LL*/) 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以
59、顺序存储结构可以带v . . . . . . 资 料. . : CDialog(CCaculatorDlg:IDD, pParent) /AFX_DATA_INIT(CCaculatorDlg) / NOTE: the ClassWizard will add member initialization here /AFX_DATA_INIT void CCaculatorDlg:DoDataExchange(CDataExchange* pDX) CDialog:DoDataExchange(pDX); /AFX_DATA_MAP(CCaculatorDlg) / NOTE: the Cla
60、ssWizard will add DDX and DDV calls here /AFX_DATA_MAP BEGIN_MESSAGE_MAP(CCaculatorDlg, CDialog) /AFX_MSG_MAP(CCaculatorDlg) ON_BN_CLICKED(IDC_ADD, OnAdd) ON_BN_CLICKED(IDC_BTN_1, OnBtn1) ON_BN_CLICKED(IDC_BTN_0, OnBtn0) 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘
61、法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . ON_BN_CLICKED(IDC_BTN_2, OnBtn2) ON_BN_CLICKED(IDC_BTN_
62、3, OnBtn3) ON_BN_CLICKED(IDC_BTN_4, OnBtn4) ON_BN_CLICKED(IDC_BTN_5, OnBtn5) ON_BN_CLICKED(IDC_BTN_6, OnBtn6) ON_BN_CLICKED(IDC_BTN_7, OnBtn7) ON_BN_CLICKED(IDC_BTN_8, OnBtn8) ON_BN_CLICKED(IDC_BTN_9, OnBtn9) ON_BN_CLICKED(IDC_CLEAR, OnClear) ON_BN_CLICKED(IDC_DIVIDE, OnDivide) ON_BN_CLICKED(IDC_EQU
63、ALS, OnEquals) ON_BN_CLICKED(IDC_MINUS, OnMinus) ON_BN_CLICKED(IDC_MULTIPLY, OnMultiply) ON_BN_CLICKED(IDC_RESET, OnReset) ON_BN_CLICKED(IDC_RBRACKETS, OnRbrackets) ON_BN_CLICKED(IDC_LBRACKETS, OnLbrackets) /AFX_MSG_MAP END_MESSAGE_MAP() / / CCaculatorDlg message handlers 范围得到不精确的数如何得到更精确的数而又不受计算机内存
64、空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . voi
65、d CCaculatorDlg:OnAdd() / TODO: Add your control notification handler code here UpdateData(); int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); /*textlen=$; textlen+1=+; textlen+2=0;*/ textlen=+; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); UpdateData(FALSE); void C
66、CaculatorDlg:OnBtn0() / TODO: Add your control notification handler code here UpdateData(); int len; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈
67、中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen=0; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); UpdateData(FALSE); void CCaculatorDlg:OnBtn1
68、() / TODO: Add your control notification handler code here UpdateData(); int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen=1; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); UpdateData(FALSE); void CCaculatorDlg:OnBtn2() 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决
69、大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . / TODO: Add your
70、 control notification handler code here int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen=2; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); UpdateData(FALSE); void CCaculatorDlg:OnBtn3() / TODO: Add your control notification handler code here int len; GetDlgIt
71、em(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen=3; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到
72、中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . void CCaculatorDlg:OnBtn4() / TODO: Add your control notification handler code here int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(tex
73、t); textlen=4; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); void CCaculatorDlg:OnBtn5() / TODO: Add your control notification handler code here int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen=5; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); 范围得到不
74、精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v
75、. . . . . . 资 料. . void CCaculatorDlg:OnBtn6() / TODO: Add your control notification handler code here int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen=6; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); void CCaculatorDlg:OnBtn7() / TODO: Add your control noti
76、fication handler code here int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); /if(GetDlgItem(IDC_EDIT1)-GetWindowText(text,50)=+|GetDlgItem(IDC_EDIT1)-GetWindowText(text,50)=- / |GetDlgItem(IDC_EDIT1)-GetWindowText(text,50)=*|GetDlgItem(IDC_EDIT1)-GetWindowText(text,50)=/) / 范围得到不精确的数如何得到更精确的数而又
77、不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料
78、. . / GetDlgItem(IDC_EDIT1)-SetWindowText(); / GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); / len=strlen(text); textlen=7; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); void CCaculatorDlg:OnBtn8() / TODO: Add your control notification handler code here int len; GetDlgItem(IDC_EDIT1)-GetWi
79、ndowText(text,50); len=strlen(text); textlen=8; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); void CCaculatorDlg:OnBtn9() 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一
80、个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . / TODO: Add your control notification handler code here int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen=9; text
81、len+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); void CCaculatorDlg:OnClear() / TODO: Add your control notification handler code here int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen-1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); void CCaculatorDlg:OnDivide() / TO
82、DO: Add your control notification handler code here 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面
83、提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . UpdateData(); int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); /*textlen=$; textlen+1=/; textlen+2=0;*/ textlen=/; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); UpdateData(FALSE); /DEL void
84、CCaculatorDlg:OnDot() /DEL /DEL / TODO: Add your control notification handler code here /DEL /DEL void CCaculatorDlg:OnEquals() 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以
85、此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . / TODO: Add your control notification handler code here UpdateData(); int num1,num2,num3,len,len1; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len
86、=strlen(text); /*textlen=$; textlen+1=#; textlen+2=0;*/ textlen=#; textlen+1=0; infix_exp_value(text,ch); /len1=strlen(ch); /chlen1=0; /chlen1+1=0; /计算后缀表达式的值 num1=postfix_exp(ch); /num1=atoi(ch1); /num2=atoi(ch2); /*if(op=+) num3=num1+num2; else if(op=-) 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘
87、的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . /MessageBox(op=-); n
88、um3=num1-num2; else if(op=*) num3=num1*num2; else if(op=/) if(num2=0) MessageBox( 亲，除数不能为零你知道不？); GetDlgItem(IDC_EDIT1)-SetWindowText(); else num3=num1/num2; */ itoa(num1,ch1,10); GetDlgItem(IDC_EDIT1)-SetWindowText(ch1); 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数
89、乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . void CCaculatorDlg:OnMinus() / TODO: Add your control
90、notification handler code here UpdateData(); int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); /*textlen=$; textlen+1=-; textlen+2=0;*/ textlen=-; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); UpdateData(FALSE); void CCaculatorDlg:OnMultiply() / TODO: Add your contro
91、l notification handler code here UpdateData(); int len; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构
92、设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); /*textlen=$; textlen+1=*; textlen+2=0;*/ textlen=*; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); UpdateData(FALSE); void CCaculatorDlg:OnReset()
93、/ TODO: Add your control notification handler code here /char ch10; /itoa(0,ch,10); GetDlgItem(IDC_EDIT1)-SetWindowText(); BOOL CCaculatorDlg:OnInitDialog() CDialog:OnInitDialog(); 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数
94、字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . / TODO: Add extra initialization here return TRUE; / return TRUE unless you set the focus to a
95、control / EXCEPTION: OCX Property Pages should return FALSE /DEL void CCaculatorDlg:OnCancelMode() /DEL /DEL CDialog:OnCancelMode(); /DEL /DEL / TODO: Add your message handler code here /DEL /DEL int CCaculatorDlg:IsNum(char c) if(c=0&c=9) return 1; else return 0; 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序
96、就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . int CCacula
97、torDlg:priority(char op1) switch(op1) case #:return 1; case ):return 2; case +: case -:return 3; case *: case /:return 4; case (:return 5; /case $:return 6; default:return 0; int CCaculatorDlg:infix_exp_value(char *infixexp, char *postfixexp) stack S; char c,w,topelement; S.get_allocator(); 范围得到不精确的
98、数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . .
99、 . . . . 资 料. . S.push(#); /topelement=S.top(); w=*infixexp; while(S.top()!=#|w!=#) if(IsNum(w) *postfixexp=w; postfixexp+; w=*(+infixexp); else if(S.top()=(&w=) S.pop(); w=*(+infixexp); else if(S.top()=(|priority(S.top()GetWindowText(text,50); len=strlen(text); textlen=); textlen+1=0; GetDlgItem(ID
100、C_EDIT1)-SetWindowText(text); UpdateData(FALSE); void CCaculatorDlg:OnLbrackets() / TODO: Add your control notification handler code here UpdateData(); int len; GetDlgItem(IDC_EDIT1)-GetWindowText(text,50); len=strlen(text); textlen=(; textlen+1=0; GetDlgItem(IDC_EDIT1)-SetWindowText(text); UpdateDa
101、ta(FALSE); int CCaculatorDlg:postfix_exp(char *A) 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到
102、要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . stack S1; int Result,a,b,c,d,e; char cha; cha=*A+; /S1.get_allocator(); while(cha!=#) if(IsNum(cha) S1.push(cha-0); /* else if(cha=$) d=S1.top(); S1.pop(); e=S1.top(); S1.pop(); S1.push(e*10+d); */ else b=S1.top(); S1.pop(); 范
103、围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可
104、以带v . . . . . . 资 料. . a=S1.top(); S1.pop(); switch(cha) case +:c=a+b;break; case -:c=a-b;break; case *:c=a*b;break; case /:c=a/b;break; S1.push(c); cha=*A+; Result=S1.top(); return Result; 6.运行与测试 程序运行时，会出现一个窗体，如下图所示 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进
105、位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . 点击附件-计算器，会弹出下面的对话框 在文本框中输入表达式 1+2*(8-5)-4/2，如下图 范围得到不精确的数如
106、何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . .
107、 . . . 资 料. . 当点击等于号的时候，会出现数字 5 在窗体的帮助一栏里可以看到本程序的版权信息 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计
108、前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带v . . . . . . 资 料. . 7.设计中存在的问题及感想 在设计本程序中，遇到了许多阻碍和瓶颈，比如 MFC 的界面如何设计，如何响应按钮函数，如何使计算器的功能完善，比如加法功能，我一开始想着在 OnAdd 函数中处理加法运算，可是只知道被加数不知道加数，直接运用加的计算功能是行不通的，后来才想到定义一个字符数组，将文本框中的字符串处理一下，先转为后缀表达式，再运算，这样实际运算时在按等号后计算的，这样解决了所有的问题。 范围得到不精确的数如何得到更精确的数而又不受计算机内存空间的限制本程序就可以解决大数相乘的问题设计思路这个程序的关键是如何保存大数的各个数字以及如何处理大数乘法的进位问题本人是运用栈的思想做的先定义一个取出一个个位数字再将为进位数的个位数字压到栈中十位上进位的数字先保存到中再从中取出一个十位数与相乘得到的个位数字再压到栈中再从中取出一个数字以此类推直到中的数字被乘完得到一个新的大数将该栈保存到栈中将销到另一个大数以此类推最终可相加得到想要的结果这其中还用到了大数相加的原理资料数据结构设计前面提到要用到栈的操作这里由于一个大数的最大长度是一定的且大数最多执行的操作是插入和删除操作所以顺序存储结构可以带
