c语言矩阵计算器

合集下载

矩阵键盘计算器

#include<reg52.h> //包含头文件，一般情况不需要改动，头文件包含特殊功能寄存器的定义#include<stdio.h>#define DataPort P0 //定义数据端口程序中遇到DataPort 则用P0 替换#define KeyPort P1sbit LATCH1=P2^2;//定义锁存使能端口段锁存sbit LATCH2=P2^3;// 位锁存bit KeyPressFlag;//定义按键标志位unsigned char code dofly_DuanMa[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};// 显示段码值0~9unsigned char code dofly_WeiMa[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//分别对应相应的数码管点亮,即位码unsigned char TempData[8]; //存储显示值的全局变量void Display(unsigned char FirstBit,unsigned char Num){static unsigned char i=0;DataPort=0; //清空数据，防止有交替重影LATCH1=1; //段锁存LATCH1=0;DataPort=dofly_WeiMa[i+FirstBit]; //取位码LATCH2=1; //位锁存LATCH2=0;DataPort=TempData[i]; //取显示数据，段码LATCH1=1; //段锁存LATCH1=0;i++;if(i==Num)i=0;}/*------------------------------------------------定时器初始化子程序------------------------------------------------*/void Init_Timer0(void){TMOD |= 0x01; //使用模式1，16位定时器，使用"|"符号可以在使用多个定时器时不受影响//TH0=0x00; //给定初值//TL0=0x00;EA=1; //总中断打开ET0=1; //定时器中断打开TR0=1; //定时器开关打开}/*------------------------------------------------定时器中断子程序------------------------------------------------*/void Timer0_isr(void) interrupt 1{TH0=(65536-2000)/256; //重新赋值2msTL0=(65536-2000)%256;Display(0,8);}void Init_INT0(void){EA=1; //全局中断开EX0=1; //外部中断0开IT0=1; //边沿触发}/*------------------------------------------------外部中断0程序------------------------------------------------*/void ISR_INT0(void) interrupt 0{KeyPressFlag=1; //表明按键有动作，可以进行按键扫描}void DelayUs2x(unsigned char t){while(--t);}void DelayMs(unsigned char t){while(t--)//大致延时1mSDelayUs2x(245);DelayUs2x(245);}}unsigned char KeyScan(void) //键盘扫描函数，使用行列反转扫描法{unsigned char cord_h,cord_l;//行列值中间变量KeyPort=0x0f; //行线输出全为0cord_h=KeyPort&0x0f; //读入列线值if(cord_h!=0x0f) //先检测有无按键按下{DelayMs(10); //去抖if((KeyPort&0x0f)!=0x0f){cord_h=KeyPort&0x0f; //读入列线值KeyPort=cord_h|0xf0; //输出当前列线值cord_l=KeyPort&0xf0; //读入行线值while((KeyPort&0xf0)!=0xf0);//等待松开并输出return(cord_h+cord_l);//键盘最后组合码值}}return(0xff); //返回该值}/*------------------------------------------------按键值处理函数，返回扫键值可以根据需要改变返回值| 1 | 2 | 3 | + || 4 | 5 | 6 | - || 7 | 8 | 9 | * || 0 | . | = | / |------------------------------------------------*/unsigned char KeyPro(void){switch(KeyScan()){case 0x7e:return 1 ;break;//0 按下相应的键显示相对应的码值case 0xbe:return 2 ;break;//1case 0xde:return 3 ;break;//2case 0xee:return '+';break;//3case 0x7d:return 4 ;break;//4case 0xbd:return 5 ;break;//5case 0xdd:return 6 ;break;//6case 0xed:return '-';break;//7case 0x7b:return 7 ;break;//8case 0xbb:return 8 ;break;//9case 0xdb:return 9 ;break;//acase 0xeb:return 'x';break;//bcase 0x77:return 0 ;break;//ccase 0xb7:return '.';break;//dcase 0xd7:return '=';break;//ecase 0xe7:return '/';break;//fdefault:return 0xff;break;}}/*------------------------------------------------主程序------------------------------------------------*/main(){unsigned char num,i,sign;unsigned char temp[8]; //最大输入8个bit firstflag;int a=0,b=0;unsigned char s;Init_INT0();Init_Timer0(); //初始化定时器0while (1) //主循环{KeyPort=0xf0;// 赋值用于中断检测if(KeyPressFlag==1){KeyPressFlag=0; //按num=KeyPro(); //扫描键盘if(num!=0xff) //如果扫描是按键有效值则进行处理{if(i==0) //输入是第一个字符的时候需要把改行清空，方便观看{for(s=0;s<8;s++) //赋值完成后把缓冲区清零，防止下次输入影响结果TempData[s]=0;}if(('+'==num)|| (i==8) || ('-'==num) || ('x'==num)|| ('/'==num) || ('='==num))//输入数字最大值8，输入符号表示输入结束{i=0; //计数器复位if(firstflag==0) //如果是输入的第一个数据，赋值给a，并把标志位置1，到下一个数据输入时可以跳转赋值给b{sscanf(temp,"%d",&a);//从一个字符串输入到变量firstflag=1;}elsesscanf(temp,"%d",&b);for(s=0;s<8;s++) //赋值完成后把缓冲区清零，防止下次输入影响结果temp[s]=0;///////////////////////if(num!='=') //判断当前符号位并做相应处理sign=num; //如果不是等号记下标志位else{firstflag=0; //检测到输入=号，判断上次读入的符合switch(sign){case '+':a=a+b;break;case '-':a=a-b;break;case 'x':a=a*b;break;case '/':a=a/b;break;default:break;}sprintf(temp,"%d",a); //打印十进制到临时缓冲区for(s=0;s<8;s++) //由于打印的是ASCII码值{if(temp[s]==0) //所以需要转换，如果为0表示null 数码管上则不能显示，所以赋值0TempData[s]=0;else if(temp[s]==0x2d)//表示负号，数码管显示负号0x40TempData[s]=0x40;elseTempData[s]=dofly_DuanMa[temp[s]-'0'];//其他0-9负号则进行ASCII 到数字处理，如当前是'3'，用'3'-'0'=3//'3'的16进制是0x33,'0'的16进制是0x30}sign=0;a=b=0; //用完后所有数据清零for(s=0;s<8;s++)temp[s]=0;}}else if(i<16){temp[i]=num+'0';TempData[i]=dofly_DuanMa[num];//输出数据i++; //输入数值累加}}}}}。

【免费下载】单片机中用矩阵键盘实现计算器

col_1=1;
col_2=1;
col_3=1;
col_4=0;
keyfind(12);
col_1=0;
col_2=0;
col_3=0;
col_4=0;
//第一列输出'0'
//第二列输出'0'
//第三列输出'0'
//第四列输出'0'
//列线输出全为'0'
flag++; //每按一下标志位加 1
while(((P1&0x0f)!=0x0f)); //等待按键释放
break; case 2:
keynum=2+col_dat; break; case 4: keynum=3+col_dat; break; case 8: keynum=4+col_dat; break; }
} void keyprocess(void) {
switch(keynum) {
case 1:if(flag==1) //flag=1 表示是第一次按下，按得是被除数 num1=7; //第一个键按下对应是数字 7 if(flag==3) //flag=3 表示是第三次按下，按的是除数 num2=7; break;
计算器
1.程序要求：
用矩阵按键实现简单的加减乘除运算。
2.程序代码：
#include <reg51.h> #include <stdio.h> sbit col_1=P1^4; sbit col_2=P1^5; sbit col_3=P1^6; sbit col_4=P1^7;
unsigned char code table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};//共阴极数码管 unsigned char keynum,flag; unsigned char num1,num2,flag1,flag2,flag3,flag4; void keyscan(void); void display(); void keyfind(unsigned char); void keyprocess(void);

简易计算器C语言代码

简易四则运算计算器计算机工具地历史而言，中国古代最早采用地一种计算工具叫筹策，又叫做算筹，这种算筹多用竹子制成，也有用木头，兽骨充当材料的，大约270枚一束，放在布袋里可随身携带。

直到今天仍在使用的住算盘，是中国古代计算工具领域中的另一项发明明代时的住算盘已经与现代的住算盘几乎相同。

17世纪初，西方国家的计算工具有了较大的发展。

英国数学家纳尔发现了“纳皮尔算筹”；英国牧师奥却德发明了圆柱形对数计算尺，这种计算尺不仅能做加减乘涂，乘方和开方运算，甚至可以计算三角函数，指数函数和对数函数。

这些计算工具不仅带动了计算的发展，也为现代计算器发展尊定了良好的基础，成为现代社会应用广泛的计算工具，如手机，操作系统上附带的多功能计算器。

项目设计目的掌握模块的划分；掌握结构体定义；掌握栈的操作；掌握函数的定义；掌握栈的基本操作；掌握VC的基本绘图库；掌握鼠标的响应操作；目设计内容设计一个含有界面的计算器，输入一个包含括号的表达式，使用栈数据类型实现整数的四则运算操作，开方运算。

项目设计要求根据分析，系统要求实现以下几点基本功能：可通过按钮输入数字、运算符；能通过按钮实现退格、清除功能；实现加、减、乘、除、开方运算功能；实现括号运算；显示运算结果；良好的交互界面。

项目详细设计功能模块图根据系统功能要求，主要含有四大模块，分别是计算器界面设计模块、计算器按键控制模块、四则混合运算模块、计算器记忆处理模块。

计算器界面设计模块：调用VC图形系统函数和字符函数画出计算器的界面，包括24个按钮和一个文本输入框。

计算机按键控制模块：计算器通过键盘按键值的判断，执行相应的操作，如接收数字输入等。

计算器计算处理模块。

计算处理模块主要完成可以包括括号的表达式运算，运算包括加，减，乘，除、开方。

计算处理模块在按键控制模块中被调用执行。

处理模块是通过栈来实现的，分别定义了两个顺序栈，一个用来存放操作符栈，一个用来存放操作数栈。

计算器记忆处理模块。

矩阵运算——C语言实现

#include "stdafx.h"#include <stdlib.h>//结构体typedef struct{double ** mat;int row;int col;}Matrix;void InitialMatrix(Matrix *T, int row,int col); //只分配空间不初始化；void InitialMatrixZero(Matrix *T,int row, int col); //初始化为0void InitialMatrixRand(Matrix *T,int row, int col); //初始化为50以内随机正整数void InputMatrix(Matrix *T); //键盘输入矩阵void DestroyMatrix(Matrix *T); // 释放矩阵空间void PrintfMatrix(Matrix *T); //矩阵输出int AddMatrix(Matrix *A,Matrix *B,Matrix *C); // 矩阵加int MinusMatrix(Matrix *A,Matrix *B,Matrix *C); // 矩阵减int MultiMatrix(Matrix *A,Matrix *B,Matrix *C); //矩阵乘法double MeanMatrix(Matrix *T); //矩阵元素均值int SubMatrix(Matrix *T1,Matrix *T2,int BeginRow,int BeginCol,int EndRow,int EndCol); //求T1的子矩阵T2;测试程序参考界面如下所示：矩阵函数测试，请选择功能，输入对应的数字：***************************************************1：输入一个矩阵，求矩阵均值；2：产生一个随机数矩阵，求矩阵均值；3：输入两个个矩阵，求矩阵和；4：输入两个个矩阵，求矩阵差；5：输入两个个矩阵，求矩阵积；6：产生两个个随机数矩阵，求矩阵和；7：产生两个个随机数矩阵，求矩阵差；8：产生两个个随机数矩阵，求矩阵积；9：求矩阵的子阵，如矩阵的2-4行，1-3列的子阵；0：结束!#include <stdio.h>#include <stdlib.h>//结构体typedef struct {double **mat;int row;int col;} Matrix;//函数声明void InitialMatrix(Matrix *T, int row, int col);void InitialMatrixZero(Matrix *T, int row, int col);void InitialMatrixRand(Matrix *T, int row, int col);void InputMatrix(Matrix *T);void DestroyMatrix(Matrix *T); // 释放矩阵空间void PrintfMatrix(Matrix *T); //矩阵输出int AddMatrix(Matrix *A, Matrix *B, Matrix *C); // 矩阵加int MinusMatrix(Matrix *A, Matrix *B, Matrix *C); // 矩阵减int MultiMatrix(Matrix *A, Matrix *B, Matrix *C); //矩阵乘法double MeanMatrix(Matrix *T); //矩阵元素均值//int SubMatrix(Matrix *T1, Matrix *T2, int BeginRow, int BeginCol, int EndRow, int EndCol); //求T1的子矩阵T2;void NMatrix(void);//求逆矩阵//主函数int main(){int inputevent;//int i, j;int row, col;Matrix T;Matrix A;Matrix B;Matrix C;printf(" 矩阵函数测试，请选择功能，输入对应的数字：\n");printf(" ***************************************************\n\n"); printf("1：输入一个矩阵，求矩阵均值；\n");printf("2：产生一个随机数矩阵，求矩阵均值；\n");printf("3：输入两个个矩阵，求矩阵和；\n");printf("4：输入两个个矩阵，求矩阵差；\n");printf("5：输入两个矩阵，求矩阵积;");printf("\n6：产生两个随机数矩阵，求矩阵和；\n");printf("7：产生两个随机数矩阵，求矩阵差；\n");printf("8：产生两个随机数矩阵，求矩阵积;\n");printf("9:求矩阵的子阵,如矩阵的2-4行D,1-3列的子阵;\n");printf("10：输入一个方阵，求其逆矩阵\n");printf("0:结束!\n");printf("\n\n选择：");scanf("%d", &inputevent);while (inputevent != 0){if (inputevent == 1) {printf("您要输入的矩阵的行数和列数e.g:5,6:");scanf("%d,%d", &row, &col);InitialMatrix(&T, row, col);InitialMatrixZero(&T, T.row, T.col);InputMatrix(&T);printf("\n矩阵的平均值为：\n%lf\n\n", MeanMatrix(&T));DestroyMatrix(&T);}if (inputevent == 2) {printf("输入您要产生的矩阵的行数和列数e.g:5,6:");scanf("%d,%d", &row, &col);InitialMatrix(&T, row, col);InitialMatrixRand(&T, row, col);MeanMatrix(&T);PrintfMatrix(&T);printf("\n矩阵的平均值为：\n%lf\n\n", MeanMatrix(&T));DestroyMatrix(&T);}if (inputevent == 3) {printf("您要输入的矩阵A的行数和列数e.g:5,6:");scanf("%d,%d", &row, &col);InitialMatrix(&A, row, col);InitialMatrixZero(&A, A.row, A.col);InputMatrix(&A);printf("您要输入的矩阵B的行数和列数e.g:5,6:");scanf("%d,%d", &row, &col);InitialMatrix(&B, row, col);InitialMatrixZero(&B, B.row, B.col);InputMatrix(&B);InitialMatrix(&C, B.row, B.col);InitialMatrixZero(&C, C.row, C.col);if (AddMatrix(&A, &B, &C) == 1) {printf("\n\n矩阵的和为：A*B\n\n");PrintfMatrix(&C);}else printf("\n\n无法计算！\n\n");DestroyMatrix(&A);DestroyMatrix(&B);DestroyMatrix(&C);}if (inputevent == 4) {printf("您要输入的矩阵A的行数和列数e.g:5,6:");scanf("%d,%d", &row, &col);InitialMatrix(&A, row, col);InitialMatrixZero(&A, A.row, A.col);InputMatrix(&A);printf("您要输入的矩阵B的行数和列数e.g:5,6:");scanf("%d,%d", &row, &col);InitialMatrix(&B, row, col);InitialMatrixZero(&B, B.row, B.col);InputMatrix(&B);InitialMatrix(&C, B.row, B.col);InitialMatrixZero(&C, C.row, C.col);if (MinusMatrix(&A, &B, &C) == 1) {printf("\n矩阵的差为：A-B=\n\n");PrintfMatrix(&C);}else printf("\n\n无法计算！\n\n");DestroyMatrix(&A);DestroyMatrix(&B);DestroyMatrix(&C);}if (inputevent == 5) {int able;printf("您要输入的矩阵A的行数和列数e.g: 5,6: ");scanf("%d,%d", &row, &col);InitialMatrix(&A, row, col);InitialMatrixZero(&A, A.row, A.col);InputMatrix(&A);printf("您要输入的矩阵B的行数和列数e.g:5,6: ");scanf("%d,%d", &row, &col);InitialMatrix(&B, row, col);InitialMatrixZero(&B, B.row, B.col);InputMatrix(&B);InitialMatrix(&C, A.row, B.col);InitialMatrixZero(&C, C.row, C.col);able = MultiMatrix(&A, &B, &C);if (able == 1) {printf("\n积为：A*B\n\n");PrintfMatrix(&C);}else printf("\n\n无法计算！\n\n");DestroyMatrix(&A);DestroyMatrix(&B);DestroyMatrix(&C);}if (inputevent == 6) {printf("您要产生的矩阵A的行数和列数e.g:5,6: ");scanf("%d,%d", &row, &col);InitialMatrix(&A, row, col);InitialMatrixRand(&A, row, col);printf("A为：\n\n");PrintfMatrix(&A);printf("您要产生的矩阵B的行数和列数e.g:5,6: ");scanf("%d,%d", &row, &col);InitialMatrix(&B, row, col);InitialMatrixRand(&B, row, col);printf("B为：\n\n");PrintfMatrix(&B);InitialMatrix(&C, A.row, A.col);InitialMatrixZero(&C, C.row, C.col);if (AddMatrix(&A, &B, &C) == 1) {printf("\n矩阵的和为：A+B=\n\n");PrintfMatrix(&C);}else printf("\n\n无法计算！\n\n");DestroyMatrix(&A);DestroyMatrix(&B);DestroyMatrix(&C);}if (inputevent == 7) {printf("您要产生的矩阵A的行数和列数e.g:5,6: ");scanf("%d,%d", &row, &col);InitialMatrix(&A, row, col);InitialMatrixRand(&A, row, col);printf("您要产生的矩阵B的行数和列数e.g:5,6: ");scanf("%d,%d", &row, &col);InitialMatrix(&B, row, col);InitialMatrixRand(&B, row, col);InitialMatrix(&C, A.row, A.col);InitialMatrixZero(&C, C.row, C.col);if (MinusMatrix(&A, &B, &C) == 1) {printf("\n矩阵的差为：A-B=\n\n");PrintfMatrix(&C);}else printf("\n\n无法计算！\n\n");DestroyMatrix(&A);DestroyMatrix(&B);DestroyMatrix(&C);}if (inputevent == 8) {printf("您要产生的矩阵A的行数和列数e.g:5,6: \n");scanf("%d,%d", &row, &col);InitialMatrix(&A, row, col);InitialMatrixRand(&A, row, col);printf("A为：\n\n");PrintfMatrix(&A);printf("您要产生的矩阵B的行数和列数e.g:5,6: \n");scanf("%d,%d", &row, &col);InitialMatrix(&B, row, col);InitialMatrixRand(&B, row, col);printf("B为：\n\n");PrintfMatrix(&B);InitialMatrix(&C, A.row, A.col);InitialMatrixZero(&C, C.row, C.col);if (MultiMatrix(&A, &B, &C) == 1) {printf("\n积为：A*B=\n\n");PrintfMatrix(&C);;}else printf("\n\n无法计算；\n\n");DestroyMatrix(&A);DestroyMatrix(&B);DestroyMatrix(&C);}if (inputevent == 9) printf("对不起，该函数尚在完善中\n\n");if (inputevent == 10) NMatrix();if (inputevent == 0)break;printf(" 矩阵函数测试，请选择功能，输入对应的数字：\n");printf(" ***************************************************\n\n"); printf("1：输入一个矩阵，求矩阵均值；\n");printf("2：产生一个随机数矩阵，求矩阵均值；\n");printf("3：输入两个个矩阵，求矩阵和；\n");printf("4：输入两个个矩阵，求矩阵差；\n");printf("5：输入两个矩阵，求矩阵积;");printf("\n6：产生两个随机数矩阵，求矩阵和；\n");printf("7：产生两个随机数矩阵，求矩阵差；\n");printf("8：产生两个随机数矩阵，求矩阵积;\n");printf("9:求矩阵的子阵,如矩阵的2-4行D,1-3列的子阵;\n");printf("10：输入一个方阵，求其逆矩阵\n");printf("0:结束!\n");printf("\n\n选择：");scanf("%d", &inputevent);}return 0;}//其他函数void InitialMatrix(Matrix *T, int row, int col){//printf("分配内存中......\n");int i;int succ = 1;//T=(Matrix *)malloc(sizeof(Matrix));T->row = row;T->col = col;T->mat = (double **)malloc(T->row * sizeof(double *));if (T->mat == NULL) {succ = 0;}else {for (i = 0; i < T->row; i++) {T->mat[i] = (double *)malloc(T->col * sizeof(double));if (T->mat[i] == NULL) {succ = 0;break;}}//if(succ==1)// printf("内存分配成功|；?\n");//else printf("内存分配失败；\n");}}void InitialMatrixZero(Matrix *T, int row, int col) { //printf("矩阵初始化为零中......\n");int i, j;for (i = 0; i < row; i++)for (j = 0; j < col; j++)T->mat[i][j] = 0;//printf("矩阵初始化为零矩阵成功；\n"); }void InitialMatrixRand(Matrix *T, int row, int col) { int i, j;for (i = 0; i < row; i++)for (j = 0; j < col; j++)(*T).mat[i][j] = rand() % 50;}void InputMatrix(Matrix *T) {printf("输入矩阵：\n");int i, j;for (i = 0; i < (*T).row; i++)for (j = 0; j < (*T).col; j++)scanf("%lf", &(*T).mat[i][j]);}void DestroyMatrix(Matrix *T){int i;for (i = 0; i < (*T).row; i++)free((*T).mat[i]);}void PrintfMatrix(Matrix *T){int i, j;for (i = 0; i < (*T).row; i++){for (j = 0; j < (*T).col; j++)printf("%lf ", (*T).mat[i][j]);printf("\n");}}int AddMatrix(Matrix *A, Matrix *B, Matrix *C){int i, j;if ((*A).row == (*B).row && (*A).col == (*B).col){for (i = 0; i < (*A).row; i++)for (j = 0; j < (*A).col; j++)(*C).mat[i][j] = (*A).mat[i][j] + (*B).mat[i][j];for (i = 0; i < (*A).row; i++)for (j = 0; j < (*A).col; j++)return 1;}else {printf("这两个矩阵不能相加！\n");return 0;}}int MinusMatrix(Matrix *A, Matrix *B, Matrix *C){int i, j;if ((*A).row == (*B).row && (*A).col == (*B).col){for (i = 0; i < (*A).row; i++)for (j = 0; j < (*A).col; j++)(*C).mat[i][j] = (*A).mat[i][j] - (*B).mat[i][j];return 1;}elseprintf("这两个矩阵不能相减！\n");return 0;}int MultiMatrix(Matrix *A, Matrix *B, Matrix *C){int i=0, j=0;int k = 0;if ((*A).col == (*B).row){for (i = 0; i < (*A).row; i++) {for (j = 0; j < (*B).col; j++)for(k=0;k <(A->col);k++)(*C).mat[i][j] += (*A).mat[i][k] * (*B).mat[k][j];}return 1;}elseprintf("这两个矩阵不能相乘！\n");return 0;}double MeanMatrix(Matrix *T) //矩阵元素均值{double mean;double sum = 0;int i, j;for (i = 0; i < (*T).row; i++)for (j = 0; j < (*T).col; j++)sum += (*T).mat[i][j];mean = sum / ((*T).row*(*T).col);return mean;}void NMatrix(void){#define M 20#define N 20int i,j,m,n;float y=1.0;float a[M][2 * M];float b[N][2 * N];float t, x;int k, T;printf("输入方阵的维数：\n"); //请输入方阵，即行和列相等的矩阵。

c语言制作简单的计算器

c语言制作简单的计算器在计算机编程领域中，C语言是一种广泛使用的编程语言之一。

它具有简单易学的特点，并且能够进行复杂的计算和逻辑处理。

今天，我们就来学习一下如何使用C语言来制作一个简单的计算器。

首先，我们需要明确我们计算器的功能和界面设计。

本次制作的计算器将具有基本的四则运算功能，即加法、减法、乘法和除法。

我们将在控制台中实现计算器的操作，并通过简单的用户界面进行交互。

接下来，我们需要创建一个C语言程序的框架。

首先，我们需要包含头文件，以便在程序中使用各种函数和变量。

我们可以使用"#include" 来引入头文件，例如：```c#include <stdio.h>```然后，我们需要定义主函数 `main()`。

在这个函数中，我们将编写计算器的逻辑代码。

让我们开始编写函数吧！首先，我们需要声明一些变量来存储用户输入的数字和运算符。

我们可以使用 `int` 来定义整数变量，并用 `char` 定义字符变量。

例如：```cint num1, num2, result;char operator;```接下来，我们需要提示用户输入要进行的运算，并读取用户输入的数字和运算符。

我们可以使用 `printf` 和 `scanf` 函数来完成这个任务，例如：```cprintf("请输入第一个数字: ");scanf("%d", &num1);printf("请输入运算符(+, -, *, /): ");scanf(" %c", &operator);printf("请输入第二个数字: ");scanf("%d", &num2);```注意，我们在读取运算符之前添加了空格，这是为了消除输入缓冲区中可能残留的换行符等字符。

接下来，我们需要编写代码来进行实际的计算操作。

用c语言设计一个多功能计算器

用C语言设计一个多功能计算器实现功能：1）具备整型数据、浮点型数据的算术（加、减、乘、除）运算功能。

依次输入第一个运算数、运算符（+，-，*，/）,第二个运算数，然后输出结果。

结果可以作为下一个运算的第一运算数。

按‘C’清屏，按‘X’退出。

例如：输入：2+5输出：72）实现单运算符表达式计算的功能。

输入的操作数可以包含整数或浮点数。

如果遇到错误的表达式，应输出错误提示信息。

输入表达式如下：例如：输入：2+5输出：7目录摘要 (1)第一章引言 (3)1.1 计算器概述 (3)第二章设计任务及要求 (5)2.1 设计任务 (5)2.2 设计要求 (6)第三章计算器硬件设计 (7)3.1 方案说明 (7)3.2 设计单片机主体电路图 (8)第四章软件设计 (9)4.1 模块介绍 (9)4.2 程序流程图 (10)4.3 程序部分 (11)第五章总结 (16)参考文献 (17)摘要：[目录]一、课程设计题目及任务要求二、设计思路三、部分程序介绍四、程序框图五、汇编程序六、参考资料[原文]一、课程设计题目及任务要求请设计十进制加减法计算器。

要求能(不同时)显示3位输入和4位输出。

二、设计思路1、操作显示设备显示设备采用八片七段共阴极LED显示器，共设置16 个键，其中数字键0～9 共十个，接下来依次是加号键、减号键、等于号、清除键。

操作设备是两行八列共16键的简单键盘。

第一行从左至右分别为0、1、2、3、4、5、6、7，第二行分别为8、9、A（+）、B（-）、C（=）、D（清除键）、E （清除键）、F（清除键），“清除键”表示程序初始化，为下次输入准备。

2、程序实现功能（1）十进制加减法计算：输入范围为（1~999），该程序输入两个定点数，每个3位，输出4位；A为加，B为减，C为等于，输出为四位计算结果。

数据输入采用规范化输入，即必须输入3个数才算完成一个运算数的输入，两个运算数之间输入运算符A或者B，输入完成按C显示计算结果；（2）计算机复位功能：DEF均为清零重启，任何时候按下DEF中一个将重新开始；三、部分程序介绍（1）主程序（START）程序开始运行初始化程序，设置输入输出口PA、PB、PC，扫描键盘，输入两个待求数据和运算符，存入寄存器，等待输入等号同时显示第二个数，运行计算程序，并将计算结果分离，输出到显示器；（2）读键子程序（RD_KB）程序分别扫描两行键盘，若有键按下则通过移位的方式计算键码；若无键按下，则将键码缓存设置为10H，判断后进行相应的跳转。

4×4_矩阵键盘计算器设计

西华大学课程设计说明书题目4×4 矩阵键盘计算器设计系(部) 电气信息学院专业(班级) 自动化3班姓名学号指导教师胡红平起止日期2012.6.10-2012.6.30计算机接口及应用课程设计任务书系(部)：电气信息学院专业：09自动化指导教师：日期：2012-6-20西华大学课程设计鉴定表摘要近几年来随着科技的飞速发展，单片机的应用正在不断深入，同时带动传统控制检测技术日益更新。

在实时检测和自动控制的单片机应用系统中，单片机往往作为一个核心部件来使用，仅单片机方面的知识是不够的，还应根据具体硬件结合，加以完善。

本任务是个简易得三位数的减法运算，用4×4 矩阵键盘及计算器设计，利用数码管实现255内的减法运算。

程序都是根据教材内和网络中的程序参考编写而成，在功能上还并不完善，限制也较多。

本任务重在设计构思与团队合作，使得我们用专业知识，专业技能分析和解决问题全面系统的锻炼。

关键词：单片机，AT89C51，矩阵键盘，数码管ABSTRACTIn recent years, along with the rapid development of science and technology, the application of SCM is unceasingly thorough, it causes the traditional control test technology increasingly updates. In real-time detection and automatic control of single-chip microcomputer application system, often as a core component to use, only microcontroller aspects of knowledge is not enough, should according to specific hardware combined, and perfects.This task is a simple three digits, subtract with 4 * 4 matrix keyboard and a calculator design, use digital tube realization within the 255 subtract. Program is according to the teaching material and within the network reference and compiled program, on the function is not perfect, restrictions also more. This task focuses on design conception and team cooperation, make us with professional knowledge, professional skills to analyze and solve problems of full system exercise.Keywords:Single-chip，AT89C51，Matrix keyboard，digital tube目录摘要 (I)ABSTRACT (II)第1章课题概述 (1)1.1 课题概述 (1)1.2 课题要求 (2)第2章系统设计 (3)2.1 设计思路 (3)2.2 框图设计 (3)2.3 知识点 (3)2.4 硬件设计 (4)2.4.1 电路原理图 (4)2.4.2 元件选择 (5)2.4.3 PCB制版及效果 (9)2.5 软件设计 (10)2.5.1 程序流程图 (10)2.6 系统仿真及调试 (11)2.6.1 硬件调试 (11)2.6.2 软件调试 (11)2.6.3 软硬件调试 (11)结论 (11)参考文献 (14)附录 (15)第1章课题概述1.1 课题概述随着当今时代的电子领域的发展，尤其是自动化的控制领域，传统的分立元件或数字逻辑电路构成的控制系统正被智能化的单片机所取代。

C语言实现矩阵计算

C语言实现矩阵计算C语言是一种广泛使用的编程语言，也是实现矩阵计算的一种常用工具。

在C语言中，我们可以使用数组来表示矩阵，并通过循环结构和算术运算符来实现矩阵计算的各种功能。

首先，我们需要实现矩阵的输入和输出功能。

在C语言中，我们可以使用二维数组来表示矩阵。

下面是一个示例代码，用来输入和显示一个矩阵：```c#include <stdio.h>//定义最大矩阵的大小#define MAX_SIZE 100//函数用于输入一个矩阵void inputMatrix(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols)printf("请输入矩阵元素：\n");for (int i = 0; i < rows; i++)for (int j = 0; j < cols; j++)scanf("%d", &matrix[i][j]);}}//函数用于显示一个矩阵void displayMatrix(int matrix[MAX_SIZE][MAX_SIZE], int rows, int cols)printf("矩阵元素为：\n");for (int i = 0; i < rows; i++)for (int j = 0; j < cols; j++)printf("%d ", matrix[i][j]);}printf("\n");}```上述代码定义了两个函数：`inputMatrix`用于输入一个矩阵，`displayMatrix`用于显示一个矩阵。

我们可以通过调用这两个函数来输入和显示矩阵。

接下来，我们可以实现矩阵的加法、减法和乘法等功能。

以下是一个示例代码，用于实现矩阵的加法：```c//函数用于计算两个矩阵的加法void addMatrix(int matrix1[MAX_SIZE][MAX_SIZE], intmatrix2[MAX_SIZE][MAX_SIZE], int result[MAX_SIZE][MAX_SIZE], int rows, int cols)for (int i = 0; i < rows; i++)for (int j = 0; j < cols; j++)result[i][j] = matrix1[i][j] + matrix2[i][j];}}```上述代码中，我们定义了一个`addMatrix`函数，该函数接受两个输入矩阵和一个结果矩阵，将两个输入矩阵的对应元素相加，并将结果存储在结果矩阵中。

矩阵运算——C语言实现

矩阵运算——C语言实现矩阵运算是线性代数中非常重要的一部分，它涉及到矩阵的加法、减法、乘法、转置等操作。

在C语言中，我们可以使用二维数组来表示和操作矩阵。

首先，我们需要定义一个表示矩阵的结构体，可以包含矩阵的行数、列数以及矩阵的元素值。

代码如下：```ctypedef structint rows; // 行数int cols; // 列数double **data; // 矩阵元素} Matrix;```在此结构体中，我们使用一个二维指针来表示矩阵的元素，其中每个指针指向一个一维数组，表示矩阵的一行。

接下来，我们可以实现一些常用的矩阵运算函数，比如矩阵的创建、销毁、加法、减法、乘法等。

1.矩阵的创建和销毁函数如下所示：```cMatrix *createMatrix(int rows, int cols)Matrix *matrix = (Matrix *)malloc(sizeof(Matrix));matrix->rows = rows;matrix->cols = cols;matrix->data = (double **)malloc(rows * sizeof(double *));for (int i = 0; i < rows; ++i)matrix->data[i] = (double *)malloc(cols * sizeof(double));}return matrix;void destroyMatrix(Matrix *matrix)for (int i = 0; i < matrix->rows; ++i)free(matrix->data[i]);}free(matrix->data);free(matrix);```这里我们使用了动态内存分配，先分配一维数组的内存，再分配二维数组的内存。

2.矩阵的加法和减法函数如下所示：```cMatrix *addMatrix(Matrix *matrix1, Matrix *matrix2)if (matrix1->rows != matrix2->rows ， matrix1->cols != matrix2->cols)return NULL;}Matrix *result = createMatrix(matrix1->rows, matrix1->cols);for (int i = 0; i < matrix1->rows; ++i)for (int j = 0; j < matrix1->cols; ++j)result->data[i][j] = matrix1->data[i][j] + matrix2->data[i][j];}}return result;Matrix *subtractMatrix(Matrix *matrix1, Matrix *matrix2)if (matrix1->rows != matrix2->rows ， matrix1->cols != matrix2->cols)return NULL;}Matrix *result = createMatrix(matrix1->rows, matrix1->cols);for (int i = 0; i < matrix1->rows; ++i)result->data[i][j] = matrix1->data[i][j] - matrix2->data[i][j];}}return result;```这里我们首先判断两个矩阵是否具有相同的行数和列数，如果不相同则无法进行加法或减法运算。

矩阵计算器

用Matlab GUI编写一个简单的矩阵计算器摘要：矩阵是线性代数的一个主要内容，又是解决众多问题的主要工具。

而矩阵运算是矩阵理论的基本内容之一。

目前，普通的计算器只能够进行数的运算，而不能够实现矩阵的运算。

随着科技的不断发展，人们对矩阵的运用也会不断的增多。

因此，制作一个矩阵计算器对当今科技的发展有一定的推动作用。

关键字：矩阵运算、Matlab GUI、计算器正文：一、矩阵的相关知识在数学上，矩阵是指纵横排列的二维数据表格，最早来自于方程组的系数及常数所构成的方阵。

这一概念由19世纪英国数学家凯利首先提出。

矩阵，是由个数组成的一个行列的矩形表格，通常用大写字母表示，组成矩阵的每一个数，均称为矩阵的元素，通常用小写字母其元素表示，其中下标都是正整数，他们表示该元素在矩阵中的位置。

比如，或表示一个矩阵，下标表示元素位于该矩阵的第行、第列。

元素全为零的矩阵称为零矩阵。

当一个矩阵的行数与烈数相等时，该矩阵称为一个阶方阵。

对于方阵，从左上角到右下角的连线，称为主对角线；而从左下角到右上角的连线称为付对角线。

若一个阶方阵的主对角线上的元素都是，而其余元素都是零，则称为单位矩阵，记为，即：。

如一个阶方阵的主对角线上（下）方的元素都是零，则称为下（上）三角矩阵，例如，是一个阶下三角矩阵，而则是一个阶上三角矩阵。

今后我们用表示数域上的矩阵构成的集合，而用或者表示数域上的阶方阵构成的集合。

矩阵是高等代数学中的常见工具，其中的一个重要用途是解线性方程组。

线性方程组中未知量的系数可以排成一个矩阵，加上常数项，则称为增广矩阵。

另一个重要用途是表示线性变换，即是诸如f(x) 4x之类的线性函数的推广。

同时也常见于统计分析等应用数学学科中。

在物理学中，矩阵于电路学、力学、光学和量子物理中都有应用；计算机科学中，三维动画制作也需要用到矩阵。

矩阵的运算是数值分析领域的重要问题。

将矩阵分解为简单矩阵的组合可以在理论和实际应用上简化矩阵的运算。

c语言实现矩阵的加减乘除求逆运算

#include〈stdio.h>＃include〈stdlib。

h〉＃define col 3#define row 3class matrix//类的定义｛private:double m［col]［row];//矩阵设置为私有的，public：matrix（）｛}//无参数的构造函数matrix（double a[col］[row])；//有参数的构造函数matrix Add(matrix ＆b）；//加法运算声明matrix Sub（matrix ＆b);//减法运算声明matrix Mul(matrix &b)；//乘法运算声明matrix Div（matrix &b)；//除法运算声明matrix Inverse（）;//求逆运算声明~matrix();//析构函数声明void display(）;//显示函数声明｝；matrix：：matrix(double a［col]［row]）//构造函数的定义｛int i,j；for（i=0;i<col;i++)for（j=0;j〈row；j++)m［i］［j］=a［i］[j];}matrix matrix:：Add(matrix &b）//加法运算{int i，j;matrix＊c=(matrix*)malloc(sizeof（matrix））;for（i=0；i<col；i++)for(j=0;j<row；j++）c—〉m［i][j]=m[i］［j］+b.m［i］［j]；return（＊c）;｝matrix matrix:：Sub(matrix ＆b)//减法运算{int i，j;matrix＊c=(matrix*）malloc（sizeof（matrix）)；for（i=0;i〈col；i++）for（j=0;j<row;j++)c->m[i][j]=m[i］［j]—b。

m［i]［j];return ＊c；}matrix matrix:：Mul（matrix &b)//乘法运算{int i,j,k；double sum=0；matrix＊c=（matrix*)malloc(sizeof（matrix)）;for（i=0;i<col；i++){for(j=0;j〈row;j++)｛for（k=0；k〈row;k++)sum+=m［i］[k］*（b.m［k］［j］）;c-〉m[i][j］=sum；sum=0；｝}return(*c)；}matrix matrix：：Div（matrix ＆b）//除法运算{//除法直接求解，参见主函数matrix c;return（c);}matrix matrix::Inverse（）//求逆运算｛//参考博客：http：///rollenholt/articles/2050662。

C语言计算器代码

printf("西安工程大学计算机01班...本程序目标：简单计算器\n\n");Sleep(1000);
printf("小组组长：");Sleep(1000);
puts("尹化荣\n");Sleep(300);
printf("小组成员：");Sleep(300);
printf("尹化荣，");Sleep(300);
{
COORD coord;
coord.X=x;
coord.Y=y;
SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), coord );
}
void hidden()//隐藏光标
{
HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
//------------------------------------------------------------------||
//迷宫游戏，所有声明：
#define Height 23 //迷宫的高度，必须为奇数
#define Width 39 //迷宫的宽度，必须为奇数
#define Wall 1
double jiafa(double a,double b);
double jianfa(double a,double b);
double chengfa(double a,double b);
double chufa(double a,double b);
intqiuyu(int a,int b);
CONSOLE_CURSOR_INFO cci;

矩阵计算C语言源代码

//#include "matrix.h"#define EX_TRUE (0)#define EX_FALSE (1)#define EX_MALLOC (2)typedefstruct tagMatrix{unsignedchar ucRow;unsignedchar ucCol;unsignedshort usRev;float *pfDataAdd;}Matrix_s;externint InputRowColInfo(unsignedchar *pucRow, unsignedchar *pucCol); externint CreateMatrixMem(void *pvData);externint InputMatrixData(void *pvData);externint PrintMatrixData(void *pvData);externint PrintInverseMatrixData(void *pvData);externint Show_matrix(Matrix_s *pstMatrixA, Matrix_s *pstMatrixB);//#include "operate_matrix.h"#define EX_MA TRIX_INIT (1)#define EX_MA TRIX_UNINIT (0)typedefenum{EX_INPUT_MATRIX = 1,EX_ADD_MA TRIX,EX_SUBTRACT_MATRIX,EX_MULTIPL Y_MA TRIX,EX_INVERSE_MA TRIX,EX_QUIT_MATRIX,EX_BOTTOM_MATRIX}Matrix_opcode_en;externint OperateMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrix);externint ShowMatrixMenu();externint CheckMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB);externint AddMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB, Matrix_s *pstMatrixC);externint SubtractMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB, Matrix_s *pstMatrixC);externint MultiplyMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB, Matrix_s *pstMatrixC);externint CreateResultMatrix(unsignedchar ucRow, unsignedchar ucCol, void *pvData); externint InverseMatrix(float a[], int n);/*Guanlin Luo ID:10529749*/#include<stdio.h>#include<stdlib.h>#include<memory.h>#include<math.h>#include"matrix.h"/*We have already done this header.*/#include"operate_matrix.h"/*We have already done this header.*/char g_cFlag = EX_MATRIX_UNINIT;int main (){int iInputOpCode;int iRet = EX_FALSE;Matrix_s stMatrixA, stMatrixB;memset(&stMatrixA, 0, sizeof(stMatrixA));memset(&stMatrixB, 0, sizeof(stMatrixB));while(1){/* show menu */(void)ShowMatrixMenu();/* operete matrix */scanf("%d", &iInputOpCode);iRet = OperateMatrix(iInputOpCode, &stMatrixA, &stMatrixB);if (EX_TRUE == iRet){if (EX_QUIT_MATRIX == iInputOpCode){break;}}}if (NULL != stMatrixA.pfDataAdd){free(stMatrixA.pfDataAdd);}if (NULL != stMatrixB.pfDataAdd){free(stMatrixB.pfDataAdd);}return EX_TRUE;}int ShowMatrixMenu()/*choices for users.*/{printf("1 - Enter matrices A & B\r\n");printf("2 - Add matrices\r\n");printf("3 - Subtract matrices\r\n");printf("4 - Multiply matrices\r\n");printf("5 - Inverse of A\r\n");printf("6 - Quit program\r\n");printf("Option: ");return EX_TRUE;}int OperateMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB) {int iRet = EX_FALSE;Matrix_s stMatrixC;float *pfTmpBuf = NULL;memset(&stMatrixC, 0, sizeof(Matrix_s));switch (iOpCode){case EX_INPUT_MA TRIX:iRet = Show_matrix(pstMatrixA, pstMatrixB);if (EX_FALSE == iRet){printf("err input matrix info!\n");return iRet;}else{/* at first, we need input matrix data */g_cFlag = EX_MA TRIX_INIT;}break;case EX_ADD_MATRIX:/*Addition part.*/iRet = AddMatrix(EX_ADD_MATRIX, pstMatrixA, pstMatrixB, &stMatrixC);if (EX_TRUE != iRet)/*For checking.*/{printf("err multiply matrix operation!\n");if (EX_MALLOC == iRet){;}else{free(stMatrixC.pfDataAdd);}return iRet;}printf("\r\nA + B =: \r\n");iRet = PrintMatrixData(&stMatrixC);if (iRet == EX_FALSE){printf("err print Matrix result!\r\n");free(stMatrixC.pfDataAdd);return iRet;}free(stMatrixC.pfDataAdd);break;case EX_SUBTRACT_MA TRIX:/*Subtract two matrices*/iRet = SubtractMatrix(EX_SUBTRACT_MATRIX, pstMatrixA, pstMatrixB, &stMatrixC);if (EX_TRUE != iRet)/*For checking.*/{printf("err subtract matrix operation!\r\n");if (EX_MALLOC == iRet){;}else{free(stMatrixC.pfDataAdd);}return iRet;}printf("\r\nA - B =: \r\n");iRet = PrintMatrixData(&stMatrixC);if (iRet == EX_FALSE){printf("err print Matrix result!\r\n");free(stMatrixC.pfDataAdd);return iRet;}free(stMatrixC.pfDataAdd);break;case EX_MULTIPL Y_MATRIX:/*multiplication part.*/iRet = MultiplyMatrix(EX_MULTIPL Y_MATRIX, pstMatrixA, pstMatrixB, &stMatrixC);if (EX_TRUE != iRet)/*For checking.*/{printf("\r\nerr multiply matrix operation!\r\n");if (EX_MALLOC == iRet){;}else{free(stMatrixC.pfDataAdd);}return iRet;}printf("\r\nA * B =: \r\n");iRet = PrintMatrixData(&stMatrixC);if (EX_TRUE != iRet){printf("err print Matrix result!\r\n");free(stMatrixC.pfDataAdd);return iRet;}free(stMatrixC.pfDataAdd);break;case EX_INVERSE_MATRIX:/*inverse.*/if (EX_MATRIX_UNINIT == g_cFlag)/*For checking the input.*/{printf("please choose 1 operation at first.\r\n");return EX_FALSE;}pfTmpBuf = (float*)malloc(pstMatrixA->ucRow * pstMatrixA->ucCol * sizeof(float));if (pfTmpBuf == NULL)/*For checking.*/{printf("err malloc memory.\r\n");return EX_MALLOC;}else{memset(pfTmpBuf, 0, (pstMatrixA->ucRow * pstMatrixA->ucCol * sizeof(float)));memcpy(pfTmpBuf, pstMatrixA->pfDataAdd, (pstMatrixA->ucRow * pstMatrixA->ucCol * sizeof(float)));}stMatrixC.ucCol = pstMatrixA->ucCol;stMatrixC.ucRow = pstMatrixA->ucRow;stMatrixC.pfDataAdd = pfTmpBuf;iRet = InverseMatrix(stMatrixC.pfDataAdd, stMatrixC.ucRow);if (EX_TRUE != iRet)/*For checking.*/{printf("\r\nerr inverse matrix operation!\r\n");if (EX_MALLOC == iRet){;}else{free(stMatrixC.pfDataAdd);}return iRet;}printf("\r\nInverse of A =: \r\n");iRet = PrintInverseMatrixData(&stMatrixC);if (EX_TRUE != iRet)/*For checking.*/{printf("err print Matrix result!\r\n");free(stMatrixC.pfDataAdd);return iRet;}free(stMatrixC.pfDataAdd);break;case EX_QUIT_MA TRIX:/*users chose to end this program.*/printf("will quit matrix menu!\r\n");break;default:/*For checking.*/printf("err operate code!\r\n");return EX_FALSE;}return EX_TRUE;}int CheckMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB) {if ((pstMatrixA == NULL) || (pstMatrixB == NULL)){printf("matrix para is null.\r\n");return EX_FALSE;}if (EX_MATRIX_UNINIT == g_cFlag){printf("please choose 1 operation at first.\r\n");return EX_FALSE;}switch (iOpCode){case EX_ADD_MATRIX:case EX_SUBTRACT_MA TRIX:if ((pstMatrixA->ucCol == pstMatrixB->ucCol)&& (pstMatrixA->ucRow == pstMatrixB->ucRow)) {;}else{/* ADD / Subtract operation */printf("\r\nAdd/Subtract operation is invalid!\r\n"); return EX_FALSE;}break;case EX_INVERSE_MATRIX:if ((2 == pstMatrixA->ucRow)&& (2 == pstMatrixA->ucCol)){;}else{/* Inverse operation */printf("\r\nMultiply/Inverse operation is invalid!\r\n"); return EX_FALSE;}break;case EX_MULTIPL Y_MATRIX:if ((pstMatrixA->ucRow == pstMatrixB->ucCol)&& (pstMatrixA->ucCol == pstMatrixB->ucRow)) {;}else{/* Multiply operation */printf("\r\nMultiply operation is invalid!\r\n");return EX_FALSE;}break;default:printf("err operate code!\r\n");return EX_FALSE;}return EX_TRUE;}int AddMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB, Matrix_s *pstMatrixC){int iRet = EX_FALSE;unsignedchar ucRow;unsignedchar ucCol;unsignedchar i, j;float fTmpData = 0.0;if ((pstMatrixA == NULL) || (pstMatrixB == NULL)){printf("matrix para is null.\r\n");return EX_FALSE;}iRet = CheckMatrix(iOpCode, pstMatrixA, pstMatrixB);if (EX_FALSE == iRet){return iRet;}else{ucRow = pstMatrixA->ucRow;ucCol = pstMatrixA->ucCol;}/* create result matrix C */iRet = CreateResultMatrix(ucRow, ucCol, pstMatrixC);if (iRet != EX_TRUE){return iRet;}for (i = 0; i < ucRow; i++){for (j = 0; j < ucCol; j++){fTmpData = (*(pstMatrixA->pfDataAdd + i * ucCol + j) + *(pstMatrixB->pfDataAdd + i * ucCol + j));*(pstMatrixC->pfDataAdd + i * ucCol + j) = fTmpData;}}return EX_TRUE;}int SubtractMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB, Matrix_s *pstMatrixC){int iRet = EX_FALSE;unsignedchar ucRow;unsignedchar ucCol;unsignedchar i, j;float fTmpData = 0.0;if ((pstMatrixA == NULL) || (pstMatrixB == NULL)){printf("matrix para is null.\r\n");return EX_FALSE;}iRet = CheckMatrix(iOpCode, pstMatrixA, pstMatrixB);if (EX_FALSE == iRet){return iRet;}else{ucRow = pstMatrixA->ucRow;ucCol = pstMatrixA->ucCol;}/* create result matrix C */iRet = CreateResultMatrix(ucRow, ucCol, pstMatrixC);if (iRet != EX_TRUE){return iRet;}for (i = 0; i < ucRow; i++){for (j = 0; j < ucCol; j++){fTmpData = (*(pstMatrixA->pfDataAdd + i * ucCol + j) - *(pstMatrixB->pfDataAdd + i * ucCol + j));*(pstMatrixC->pfDataAdd + i * ucCol + j) = fTmpData;}}return EX_TRUE;}int MultiplyMatrix(int iOpCode, Matrix_s *pstMatrixA, Matrix_s *pstMatrixB, Matrix_s *pstMatrixC){int iRet = EX_FALSE;unsignedchar ucRow;unsignedchar ucCol;unsignedchar i, j, k;float fTmpData = 0.0;if ((pstMatrixA == NULL) || (pstMatrixB == NULL)){printf("matrix para is null.\r\n");return EX_FALSE;}iRet = CheckMatrix(iOpCode, pstMatrixA, pstMatrixB);if (EX_FALSE == iRet){return iRet;}else{ucRow = pstMatrixA->ucRow;ucCol = pstMatrixB->ucCol;}/* create result matrix C */iRet = CreateResultMatrix(ucRow, ucCol, pstMatrixC);if (iRet != EX_TRUE){return iRet;}for (i = 0; i < ucRow; i++){for (j = 0; j < ucCol; j++){for (k = 0; k < pstMatrixA->ucCol; k++){fTmpData += (float)(*(pstMatrixA->pfDataAdd + i * ucCol + k) * *(pstMatrixB->pfDataAdd + j + k * ucCol));}*(pstMatrixC->pfDataAdd + i * ucCol + j) = fTmpData;fTmpData = 0;}}return EX_TRUE;}int CreateResultMatrix(unsignedchar ucRow, unsignedchar ucCol, void *pvData){Matrix_s *pstTmpData = NULL;int iRet = EX_FALSE;if (pvData == NULL){printf("para is null.\r\n");return EX_FALSE;}else{pstTmpData = (Matrix_s *)pvData;}/* create result matrix C */memset(pstTmpData, 0, sizeof(Matrix_s));pstTmpData->ucRow = ucRow;pstTmpData->ucCol = ucCol;iRet = CreateMatrixMem(pstTmpData);if (iRet != EX_TRUE){printf("err create result Matrix C!\r\n"); return iRet;}return EX_TRUE;}int InverseMatrix(float a[], int n){int *is,*js;int i,j,k,l,u,v;float d, p;is = (int *)malloc(n * sizeof(int));js = (int *)malloc(n * sizeof(int));for (k = 0; k <= n-1; k++){d = 0.0;for (i = k; i <= n-1; i++){ for (j = k; j <= n-1; j++){l = i * n + j;p = (float)fabs(a[l]);if (p > d){d = p;is[k] = i;js[k] = j;}}}if (d + 1.0 == 1.0){free(is);free(js);printf("err not inverse!\r\n"); return EX_FALSE;}if (is[k] != k){ for (j=0; j<=n-1; j++){u = k * n + j;v = is[k] * n +j;p = a[u];a[u] = a[v];a[v] = p;}}if (js[k] != k){for (i=0; i<=n-1; i++){u = i*n+k;v = i*n+js[k];p = a[u];a[u] = a[v];a[v] = p;}}l = k * n + k;a[l] = (float)(1.0 / a[l]);for (j = 0; j <= n-1; j++){if (j != k){u = k * n + j;a[u] = a[u] * a[l];}}for (i = 0; i <= n-1; i++){if (i != k){for (j = 0; j <= n-1; j++){if (j != k){u = i * n + j;a[u] = a[u] - a[i * n + k] * a[k * n + j];}}for (i = 0; i <= n-1; i++){if (i != k){u = i * n + k;a[u] = -a[u] * a[l];}}}}}for (k = n-1; k >= 0; k--){if (js[k] != k)for (j = 0; j <= n-1; j++){u = k * n + j;v = js[k] * n + j;p = a[u];a[u] = a[v];a[v] = p;}if (is[k] != k)for (i = 0; i <= n-1; i++){u = i * n + k;v = i * n + is[k];p = a[u];a[u] = a[v];a[v] = p;}}free(is);free(js);return EX_TRUE;}。

C语言课程设计--计算器(图形界面)

C语言课程设计--计算器(图形界面)扬州大学C语言课程设计报告题目一个简易计算器的设计与实现班级学号姓名指导教师成绩老师评语：第 2 页共 14 页第 3 页共 14 页一、系统调试…………………………………………8，9，10，11二、课程设计体会总结………………………………8，9，10，111 课程设计目的（1）.课程设计是一项综合性实践环节，是对平时实验的一个补充，课程设计内容包括课程的主要理论知识，但由于C语言对初学者较难掌握，因而对一个完整的C语言程序不适合平时实验。

通过课程设计可以达到综合设计C语言程序的目的。

（2）通过本课程设计，可以培养独立思考，综合运用所学有关相应知识的能力，能更好地使用C语言的知识，更好地了解C语言的好处和其可用性！掌握基本的程序设计过程和技巧，掌握基本的分析问题和利用计算机求解问题的能力，具备初步的高级程序设计能力。

为后续各门计算机课程的学习和毕业设计打下坚实基础！（3）通过本程序训练程序设计的基本技能，掌握字符串的表示方法和字符串函数的功能、自学掌握四则运算的算法及WIN-TC的图形操作的基本知识、键盘上特殊键的获取及图形方式下光标的显示。

2 课程设计内容目的：本课程的课程设计要求学生模拟实现一个简单计算器，要求（1）能够实现四则运算，并能支持优先级运算。

（2）三角与反三角运算：如sinx，cosx等。

（3）指数对数运算：如log（x）,lnx,e的x次方等。

（4）其他运算：如X！，x 的累加等。

（4）不允许调用库函数，使用自行开发的程序实现常用函数运算。

（5）进一步考虑计算器外观设计，用可视化界面给出计算器外观、功能按键及输入界面。

使用说明：执行加法运算，'—'表示执行减法运算，表示执行乘法运算，'/'表第 4 页共 14 页示除法运算．‘Q’表示退出计算器‘C’表示清零,’=’表示得出结果'^'表示执行x的y次方,'e'表示执行e的x次方操作，'&'表示执行累加操作.，你可以可以用键盘上的上下左右键对光标进行移动，当光标移动到计算器按键上时，按ENTER即可执行该键的操作!最后按“=”则可得出结果。

矩阵计算器代码实现 C语言

#include<iostream>#include<stdlib.h>#include<math.h>#define N 10 //定义方阵的最大阶数为10#include <iomanip>using namespace std;double MatDet(double *p, int n); //求矩阵的行列式double Creat_M(double *p, int m, int n, int k); //求矩阵元素A(m, n)的代数余子式void print(double *p, int n); //输出矩阵n*nclass Matrix{private:int row,col;double **eM ;public:creatM();//创造矩阵outM(Matrix A);//输出矩阵add(Matrix A,Matrix B);//矩阵相加minus(Matrix A,Matrix B);//矩阵相减transpose(Matrix A);//矩阵转置mutiply(Matrix A,Matrix B);//矩阵相乘h(Matrix A);//求行列式,和上三角inverse(Matrix A);//矩阵的逆};void main(){cout<<"******矩阵计算器******"<<endl;cout<<"请选择你要进行的操作"<<"\n"<<"1:相加2:相减3：转置4：相乘5：求行列式和上三角6:求逆"<<endl;int c;cin>>c;switch(c){case 1:{Matrix m1,m2;cout<<"请输入第一个矩阵"<<endl;m1.creatM();cout<<"请输入第二个矩阵"<<endl;m2.creatM();m1.add(m1,m2);break;}case 2:{Matrix m1,m2;cout<<"请输入第一个矩阵"<<endl;m1.creatM();cout<<"请输入第二个矩阵"<<endl;m2.creatM();m1.minus(m1,m2);break;}case 3:{Matrix A;A.transpose(A);break;}case 4:{Matrix m1,m2;cout<<"请输入第一个矩阵"<<endl;m1.creatM();cout<<"请输入第二个矩阵"<<endl;m2.creatM();m1.mutiply(m1,m2);break;}case 5:{Matrix m;cout<<"请输入矩阵"<<endl;m.creatM();m.h(m);break;}case 6:{double *buffer, *p; //定义数组首地址指针变量int row, num; //定义矩阵的行数和矩阵元素个数int i, j;double determ; //定义矩阵的行列式double a[N][N], b[N][N];int n;cout << "采用逆矩阵的定义法求矩阵的逆矩阵!\n";cout << "请输入矩阵的行数: ";cin >> row;num = 2 * row * row;buffer = (double *)calloc(num, sizeof(double)); //分配内存单元p = buffer;if (NULL != p){for (i = 0; i < row; i++){cout << "Please input the number of " << i+1 << " row: ";for (j = 0; j < row; j++){cin >> *p++;}}}else{cout << "无法分配内存\n";}cout << "The original matrix : \n";print(buffer, row); //打印该矩阵determ = MatDet(buffer, row); //求整个矩阵的行列式p = buffer + row * row;if (determ != 0){cout << "The determinant of the matrix is " << determ << endl;for (i = 0; i < row; i++) //求逆矩阵{for (j = 0; j < row; j++){*(p+j*row+i) = (double)Creat_M(buffer, i, j, row)/determ;}}cout << "The inverse matrix is: " << endl;print(p, row); //打印该矩阵}else{cout << "The determinant is 0, and there is no inverse matrix!\n"; }free(buffer); //释放内存空间getchar();break;}}}Matrix::creatM(){cout<<"请依次输入矩阵的行和列"<<endl;cin>>row>>col;eM=(double**) malloc(row*sizeof(double*)) ;for(int i=0; i<row; i++)eM[i] = (double *)malloc(col * sizeof(double));cout<<"请输入矩阵"<<endl;for( i=0;i<row;i++){for(int j=0;j<col;j++)cin>>eM[i][j] ;}}Matrix::outM(Matrix A){for(int i=0;i<row;i++){for(int j=0;j<col;j++)cout<<eM[i][j]<<" ";cout<<endl;}}Matrix::add(Matrix A, Matrix B){if(A.col!=B.col || A.row!=B.row){cout<<"行列不同"<<endl;}else{for(int i=0;i<A.row;i++){for(int j=0;j<A.col;j++){A.eM[i][j]=A.eM[i][j]+B.eM[i][j];}}cout<<"结果为：\n";A.outM(A);}}Matrix::minus(Matrix A, Matrix B){if(A.col!=B.col || A.row!=B.row){cout<<"行列不同"<<endl;}else{for(int i=0;i<A.row;i++){for(int j=0;j<A.col;j++){A.eM[i][j]=A.eM[i][j]+B.eM[i][j];}}cout<<"结果为：\n";A.outM(A);}}Matrix::transpose(Matrix A){int i,j;cout<<"请输入矩阵"<<endl;A.creatM();cout<<"原矩阵为：\n";A.outM(A);Matrix R;R.row=A.col;R.col=A.row;R.eM=(double**) malloc(R.row*sizeof(double*)) ;for( i=0; i<R.row; i++)R.eM[i] = (double *)malloc(R.col * sizeof(double));for(i=0;i<R.row;i++){for(int j=0;j<R.col;j++){R.eM[i][j]=0;}}for(i=0;i<R.row;i++){for(int j=0;j<R.col;j++){R.eM[i][j]=A.eM[j][i];}}cout<<"结果为："<<endl;R.outM(R);}Matrix::mutiply(Matrix A, Matrix B){if(A.col!=B.row){cout<<"不能相乘"<<endl;}else{int i;Matrix R;R.row=A.row;R.col=B.col;R.eM=(double**) malloc(R.row*sizeof(double*)) ;for( i=0; i<row; i++)R.eM[i] = (double *)malloc(R.col * sizeof(double));for(i=0;i<R.row;i++){for(int j=0;j<R.col;j++){R.eM[i][j]=0;}}for(i=0;i<R.row;i++){for(int j=0;j<R.col;j++){for(int k=0;k<A.col;k++){R.eM[i][j]+=A.eM[i][k]*B.eM[k][j];}}}cout<<"结果为：\n"<<endl;R.outM(R);}}Matrix::h(Matrix A){if(A.col!=A.row){cout<<"不是方阵"<<endl;}else{int ii,jj,k,u;int iter = 0; //记录行变换的次数（交换）double det1=1,yin;int n=A.row;for(ii=0 ; ii<n; ii++){if(A.eM[ii][ii] == 0)for(jj=ii; jj<n; jj++){if(A.eM[jj][ii] != 0){double temp1;for(int i=0 ; i<n ; i++);{temp1 = A.eM[ii][i];A.eM[ii][i] = A.eM[jj][i];A.eM[ii][i] = temp1;}iter ++;}}for(k=ii+1; k<n; k++){yin = -1 * A.eM[k][ii] / A.eM[ii][ii] ;for(u=0; u<n; u++){A.eM[k][u] = A.eM[k][u] + A.eM[ii][u] * yin;}}}for(ii=0; ii<n; ii++) //求对角线的积即行列式的值det1 = det1 * A.eM[ii][ii];//行变换偶数次符号不变if(iter%2 == 1)det1= -det1;cout<<"矩阵的行列式的值为："<<det1<<endl;cout<<"转换的上三角矩阵为："<<endl;for(int i=0; i<n; i++){for(int j=0; j<n; j++){cout<<" "<<A.eM[i][j];}cout<<endl;}cout<<endl;}}double MatDet(double *p, int n){int ii,jj,k,u;int iter = 0; //记录行变换的次数（交换）double det1=1,yin;for(ii=0 ; ii<n; ii++){if(*(p+ii*n+ii) == 0)for(jj=ii; jj<n; jj++){if(*(p+jj*n+ii) != 0){double temp1;for(int i=0 ; i<n ; i++){temp1 = *(p+ii*n+i);*(p+ii*n+i) = *(p+jj*n+i);*(p+ii*n+i) = temp1;}iter ++;}}for(k=ii+1; k<n; k++){yin = -1 * (*(p+k*n+ii)) / (*(p+ii*n+ii)) ;for(u=0; u<n; u++){*(p+k*n+u) = *(p+k*n+u) + *(p+ii*n+u) * yin;}}}for(ii=0; ii<n; ii++) //求对角线的积即行列式的值det1 = det1 * (*(p+ii*n+ii));//行变换偶数次符号不变if(iter%2 == 1)det1= -det1;return det1;}//----------------------------------------------------------------------------//功能: 求k*k矩阵中元素A(m, n)的代数余之式//入口参数: k*k矩阵的首地址，矩阵元素A的下标m,n,矩阵行数k//返回值: k*k矩阵中元素A(m, n)的代数余之式//----------------------------------------------------------------------------double Creat_M(double *p, int m, int n, int k){int len,t;int i, j;double mid_result = 0;int sign = 1;double *p_creat, *p_mid;len = (k-1)*(k-1); //k阶矩阵的代数余之式为k-1阶矩阵p_creat = (double*)calloc(len, sizeof(double)); //分配内存单元p_mid = p_creat;for (i = 0; i < k; i++){for (j = 0; j < k; j++){if (i != m && j != n) //将除第i行和第j列外的所有元素存储到以p_mid为首地址的内存单元{*p_mid++ = *(p+i*k+j);}}}sign = ((m+n)%2 == 0 ? 1 : -1);//代数余之式前面的正、负号t=MatDet(p_creat, k-1);mid_result = sign*t;return mid_result;free(p_creat);}//-----------------------------------------------------//功能: 打印n*n矩阵//入口参数: n*n矩阵的首地址,矩阵的行数n//返回值: 无返回值//-----------------------------------------------------void print(double *p, int n){int i, j;for (i = 0; i < n; i++){cout << setw(4);for (j = 0; j < n; j++){cout << setiosflags(ios::right) << *p++ << setw(10);}cout << endl;}}。

用C语言实现矩阵运算

}
}
for(i=0;i<R1;i++)
{
for(j=0;j<C1;j++)
{
MF[i][j]=MA[i][j]-MB[i][j];
}
}
for(i=0;i<R1;i++)
{
for(j=0;j<C1;j++)
{
printf("%6.2f ",MF[i][j]);
}
printf("\n");
}
}
void Multiplication(float MA[][C1],float MB[][C2])//矩阵相乘函数
for(i=0;i<R2;i++)
{
for(j=0;j<C2;j++)
{
scanf("%f",&MB[i][j]);
}
}
for(i=0;i<R1;i++)
{
for(j=0;j<C1;j++)
{
ME[i][j]=MA[i][j]+MB[i][j];
}
}
for(i=0;i<R1;i++)
{
for(j=0;j<C1;j++)
{
int i,j,k;
float MG[R1][C2]={0};
printf("请输入%d*%d矩阵MA(每行以回车结束):\n",R1,C1);
for(i=0;i<R1;i++)
{
for(j=0;j<C1;j++)

C++矩阵运算类库(很实用)

C++进行矩阵运算类库头文件：Matrix.h＃ifndef MATRIX_H＃define MATRIX_H＃include "iostream”＃include ”string”#include <stdlib.h>#include <vector>＃include 〈fstream〉＃include〈sstream〉 //istringstream 必须包含这个头文件using namespace std;class Matrix｛public:void readMatrix(string fileName）;void showMatrix(）;void writeMatrix（string str);void inversion（）;//求矩阵的逆矩阵void change（);//求矩阵的转置void operator +（Matrix ＆a)；//声明重载运算符的“+”函数void operator —（Matrix &a）；//声明重载运算符的“-"函数void operator *(Matrix ＆a);//声明重载运算符的“*”函数void operator =（Matrix &a）；//声明重载运算符的“=”赋值函数vector<vector<double>> _mat;int row；int col；｝；#endif源文件：main.cpp＃include ”iostream”#include "string"＃include <stdlib.h>＃include <vector>＃include 〈fstream>#include<sstream〉 //istringstream 必须包含这个头文件＃include "Matrix.h"#include 〈time.h〉 //使用随机数＃include 〈cmath〉 //数学计算using namespace std;//将运算得到的数据存储到box中,形成一个完整的Matrix量Matrix box_mul;//矩阵相乘的结果Matrix box_inver；//矩阵的逆的结果Matrix box_change;//矩阵转置的结果Matrix box_plus;//矩阵加的结果Matrix box_cut；//矩阵减的结果void Matrix:：readMatrix(string fileName）{ifstream ifile（fileName。

C矩阵简单的计算器

C++课程设计---矩阵简单的计算器一、设计目的1、熟练把握和运用c++编写程序代码的能力。

2、初步了解输入、成立并输出矩阵和矩阵加法、减法、乘法、赋值和转置的算法设计。

3、把握大体的运算符重载函数的书写。

4、把握静态数据成员和静态成员函数的具体声明和实现，体会它们的特殊作用。

五、把握并体会动态内存分派的实际应用。

六、运用简单的循环实现简单的菜单程序。

二、整体设计(1)UML图(2)流程图三、详细设计（1）类中的函数功能及实现1、有参数的构造函数Matrix(int l,int w,int *n);实现：Matrix::Matrix(int l,int w,int *n){length=l;width=w;num=new int[length*width];int *p=num;for(int i=0;i<length*width;i++){*p++=*n++;}}说明：为有参数的对象变量初始化。

2、无参构造函数（默许形式的构造函数）Matrix()实现：Matrix::Matrix(){length=1;width=1;num=new int(1);}说明：为无参数的对象进行初始化。

3、矩阵的拷贝构造函数Matrix::Matrix(Matrix &jz)实现：Matrix::Matrix(Matrix &jz){length=;width=;num=new int[length*width];for(int i=0;i<length*width;i++){*(num+i)=*+i);}}目的：用已存在的对象jz去初始化新成立的对象。

4、矩阵输入函数void Matrix::setnum(int l,int w)实现：void Matrix::setnum(int l,int w){length=l;width=w;if(l==0||w==0){cout<<"矩阵行列不能为0"<<endl;return ;}else{delete[]num;num=NULL;num=new int[length*width]; （请单击）六、程序结果以下通过截图显示清楚的矩阵简单的计算器功能。

c语言 矩阵计算器

矩阵键盘计算器

【免费下载】单片机中用矩阵键盘实现计算器

简易计算器C语言代码

矩阵运算——C语言实现

c语言制作简单的计算器

用c语言设计一个多功能计算器

4×4_矩阵键盘计算器设计

C语言实现矩阵计算

矩阵运算——C语言实现

矩阵计算器

c语言实现矩阵的加减乘除求逆运算

C语言计算器代码

矩阵计算C语言源代码

C语言课程设计--计算器(图形界面)

矩阵计算器代码实现 C语言

用C语言实现矩阵运算

C++矩阵运算类库(很实用)

C矩阵简单的计算器

c语言矩阵计算器