编译复杂的计算器程序

⑴ 用VB做复杂计算器怎么做

如何用VB做一个简单计算器
要求实现加减乘除乘方开方功能
用0~9按钮实现
用记事本把这段代码复制过去，然后另存为.frm就可以了
VERSION
5.00
Begin

⑵ 复杂计算器的设计 java

我收藏的计算器代码。自己编译一下。应该可以满足你的要求了。
import javax.swing.*;
import javax.swing.event.*;
import java.awt.*;
import java.awt.event.*;

public class calculator extends JFrame implements ActionListener
{//这里我把JFrame写成Frame，这个错误找了好久
JFrame frame;

private JButton jia=new JButton("+");
private JButton jian=new JButton("-");
private JButton cheng=new JButton("*");
private JButton chu=new JButton("/");
private JButton qiuyi=new JButton("%");
private JButton deng=new JButton("=");
private JButton fu=new JButton("+/-");
private JButton dian=new JButton(".");
private JButton kai=new JButton("sqrt");
private JButton diao=new JButton("1/x");
private JButton aa=new JButton("A");
private JButton bb=new JButton("B");
private JButton cc=new JButton("C");
private JButton dd=new JButton("D");
private JButton ee=new JButton("E");
private JButton ff=new JButton("F");

private TextField k1=new TextField();
private objConversion convert = new objConversion();

JMenuItem ,paste,s,t,help,about,me;
JRadioButton sixteen,ten,eight,two;
JButton backspace,ce,c,num0,num1,num2,num3,num4,num5,num6,num7,num8,num9;
Container cp;

JTextField text;
String content="";
boolean clickable=true,clear=true;
int all=0;
double qian;
String fuhao;
int jin=10,first=1;

public calculator()
{
setTitle("计算器－杨彩制作");
setSize(400,300);
setLocation(250,200);
text=new JTextField(25);
// text.setEnabled(false);
text.setText("0.");
text.setHorizontalAlignment(JTextField.RIGHT);//从右到左

JPanel cp1=new JPanel();
JPanel cp2=new JPanel();
JPanel cp3=new JPanel();

cp=getContentPane();
cp.add(cp1,"North");
cp.add(cp2,"Center");
cp.add(cp3,"South");

cp1.setLayout(new GridLayout(1,6));
cp2.setLayout(new GridLayout(2,4));
cp3.setLayout(new GridLayout(6,6));

sixteen=new JRadioButton("十六进制");
sixteen.setVisible(false);
ten=new JRadioButton("十进制",true);
ten.setVisible(false);
eight=new JRadioButton("八进制");
eight.setVisible(false);
two=new JRadioButton("二进制");
two.setVisible(false);
sixteen.addActionListener(this);
ten.addActionListener(this);
eight.addActionListener(this);
two.addActionListener(this);
ButtonGroup btg=new ButtonGroup();

btg.add(sixteen);
btg.add(ten);
btg.add(eight);
btg.add(two);

JTextField t3=new JTextField(25);
cp1.add(text);
// text.setEnabled(false);
text.setEditable(false);
text.setBackground(new Color(255, 255, 255));

cp2.add(sixteen);
cp2.add(ten);
cp2.add(eight);
cp2.add(two);

backspace=new JButton("Backspace");
backspace.setForeground(new Color(255,0,0));
backspace.addActionListener(this);
ce=new JButton("CE");
ce.setForeground(new Color(255,0,0));
ce.addActionListener(this);
c=new JButton("C");
c.setForeground(new Color(255,0,0));
c.addActionListener(this);
k1.setVisible(false);
cp2.add(k1);
cp2.add(backspace);
cp2.add(ce);
cp2.add(c);

num0=new JButton("0");
num1=new JButton("1");
num2=new JButton("2");
num3=new JButton("3");
num4=new JButton("4");
num5=new JButton("5");
num6=new JButton("6");
num7=new JButton("7");
num8=new JButton("8");
num9=new JButton("9");

cp3.add(num7);
num7.addActionListener(this);
cp3.add(num8);
num8.addActionListener(this);
cp3.add(num9);
num9.addActionListener(this);
cp3.add(chu);
chu.setForeground(new Color(255,0,0));
chu.addActionListener(this);
cp3.add(kai);
kai.addActionListener(this);
cp3.add(num4);
num4.addActionListener(this);
cp3.add(num5);
num5.addActionListener(this);
cp3.add(num6);
num6.addActionListener(this);
cp3.add(cheng);
cheng.setForeground(new Color(255,0,0));
cheng.addActionListener(this);
cp3.add(qiuyi);
qiuyi.addActionListener(this);
cp3.add(num1);
num1.addActionListener(this);
cp3.add(num2);
num2.addActionListener(this);
cp3.add(num3);
num3.addActionListener(this);
cp3.add(jian);
jian.setForeground(new Color(255,0,0));
jian.addActionListener(this);
cp3.add(diao);
diao.addActionListener(this);
cp3.add(num0);
num0.addActionListener(this);
cp3.add(fu);
fu.addActionListener(this);
cp3.add(dian);
dian.addActionListener(this);
cp3.add(jia);
jia.setForeground(new Color(255,0,0));
jia.addActionListener(this);
cp3.add(deng);
deng.setForeground(new Color(255,0,0));
deng.addActionListener(this);
cp3.add(aa);
aa.addActionListener(this);
cp3.add(bb);
bb.addActionListener(this);
cp3.add(cc);
cc.addActionListener(this);
cp3.add(dd);
dd.addActionListener(this);
cp3.add(ee);
ee.addActionListener(this);
cp3.add(ff);
ff.addActionListener(this);
aa.setVisible(false);
bb.setVisible(false);
cc.setVisible(false);
dd.setVisible(false);
ee.setVisible(false);
ff.setVisible(false);

JMenuBar mainMenu = new JMenuBar();
setJMenuBar(mainMenu);
JMenu editMenu = new JMenu("编辑");
JMenu viewMenu = new JMenu("查看");
JMenu helpMenu = new JMenu("帮助");
mainMenu.add(editMenu);
mainMenu.add(viewMenu);
mainMenu.add(helpMenu);

= new JMenuItem(" 复制");
paste = new JMenuItem(" 粘贴");
KeyStroke ks=KeyStroke.getKeyStroke(KeyEvent.VK_C,Event.CTRL_MASK);
.setAccelerator(ks);//设置退出菜单选项加上快捷键
KeyStroke pasteks=KeyStroke.getKeyStroke(KeyEvent.VK_V,Event.CTRL_MASK);
paste.setAccelerator(pasteks);//设置退出菜单选项加上快捷键
editMenu.add();
editMenu.add(paste);
.addActionListener(this);
paste.addActionListener(this);

t = new JMenuItem("●标准型");
s = new JMenuItem(" 科学型");
viewMenu.add(t);
viewMenu.add(s);
t.addActionListener(this);
s.addActionListener(this);

help = new JMenuItem(" 帮助主题");
about = new JMenuItem(" 关于计算器");
me = new JMenuItem(" 作者主页");
helpMenu.add(help);
helpMenu.add(about);
helpMenu.add(me);
help.addActionListener(this);
about.addActionListener(this);
me.addActionListener(this);

addWindowListener(new WindowDestroyer());//结束窗口
}

public void actionPerformed(ActionEvent e)

{//响应动作代码

if(first==1)
text.setText("");
first=0;//第一次把文本框0.清空

Object temp = e.getSource();

if(temp==)
{
content = text.getText();
}
if(temp==paste)
{
text.setText(text.getText()+content);

}
if(temp==t)
{//标准

sixteen.setVisible(false);
ten.setVisible(false);
eight.setVisible(false);
two.setVisible(false);
t.setText("●标准型");
s.setText(" 科学型");
aa.setVisible(false);
bb.setVisible(false);
cc.setVisible(false);
dd.setVisible(false);
ee.setVisible(false);
ff.setVisible(false);
}
if(temp==s)
{//科学

sixteen.setVisible(true);
ten.setVisible(true);
eight.setVisible(true);
two.setVisible(true);
t.setText(" 标准型");
s.setText("●科学型");
aa.setVisible(true);
bb.setVisible(true);
cc.setVisible(true);
dd.setVisible(true);
ee.setVisible(true);
ff.setVisible(true);
aa.setEnabled(false);
bb.setEnabled(false);
cc.setEnabled(false);
dd.setEnabled(false);
ee.setEnabled(false);
ff.setEnabled(false);

}
if(temp==help)
{ //打开系统帮助文件 要查资料
try
{
String filePath = "C:/WINDOWS/Help/calc.chm";
Runtime.getRuntime().exec("cmd.exe /c "+filePath);

}
catch(Exception eeee)
{
System.out.println("打开系统的计算器出错");
}
}
if(temp==about)
{
JOptionPane.showMessageDialog(frame," Java计算器 杨彩 制作 http://blog.sina.com.cn/m/yangcai","关于计算器",JOptionPane.INFORMATION_MESSAGE); ;
}
if(temp==me)
{
try
{
Process p = Runtime.getRuntime().exec("explorer http://blog.sina.com.cn/m/yangcai");
}
catch(Exception eeee)
{
System.out.println("打开指定网页出错");
}
}

try
{
if(temp==sixteen)
{
String hex=text.getText();
int inthex=Integer.parseInt(hex,jin);//先把数变为10进制
text.setText(convert.decHex(inthex)) ;
jin=16;
aa.setEnabled(true);
bb.setEnabled(true);
cc.setEnabled(true);
dd.setEnabled(true);
ee.setEnabled(true);
ff.setEnabled(true);
num2.setEnabled(true);
num3.setEnabled(true);
num4.setEnabled(true);
num5.setEnabled(true);
num6.setEnabled(true);
num7.setEnabled(true);
num8.setEnabled(true);
num9.setEnabled(true);

}
if(temp==eight)
{
String oct =text.getText();
int intoct=Integer.parseInt(oct,jin);
text.setText(convert.decOct(intoct)) ;
jin=8;

aa.setEnabled(false);
bb.setEnabled(false);
cc.setEnabled(false);
dd.setEnabled(false);
ee.setEnabled(false);
ff.setEnabled(false);
num2.setEnabled(true);
num3.setEnabled(true);
num4.setEnabled(true);
num5.setEnabled(true);
num6.setEnabled(true);
num7.setEnabled(true);
num8.setEnabled(false);
num9.setEnabled(false);
}
if(temp==two)
{
String bin=text.getText();
int intbin=Integer.parseInt(bin,jin);
text.setText(convert.decBin(intbin));
jin=2;

aa.setEnabled(false);
bb.setEnabled(false);
cc.setEnabled(false);
dd.setEnabled(false);
ee.setEnabled(false);
ff.setEnabled(false);
num2.setEnabled(false);
num3.setEnabled(false);
num4.setEnabled(false);
num5.setEnabled(false);
num6.setEnabled(false);
num7.setEnabled(false);
num8.setEnabled(false);
num9.setEnabled(false);
}
if(temp==ten)
{
String dec=text.getText();
int intdec=Integer.parseInt(dec,jin);
// text.setText(convert.decDec(intdec)); //本句会把123变成321
text.setText(intdec+"");
jin=10;
aa.setEnabled(false);
bb.setEnabled(false);
cc.setEnabled(false);
dd.setEnabled(false);
ee.setEnabled(false);
ff.setEnabled(false);
num2.setEnabled(true);
num3.setEnabled(true);
num4.setEnabled(true);
num5.setEnabled(true);
num6.setEnabled(true);
num7.setEnabled(true);
num8.setEnabled(true);
num9.setEnabled(true);
}
}
catch(Exception ee)
{
System.out.println("转换出错,可能你没有输入任何字符");
text.setText("转换出错");
clear=false;
}

if(temp==backspace)
{//退格
String s = text.getText();
text.setText("");
for (int i = 0; i < s.length() - 1; i++)
{
char a = s.charAt(i);
text.setText(text.getText() + a);
}
}

if (temp==ce)
{
text.setText("0.");
clear=true;
first=1;
}
if (temp==c)
{
text.setText("0."); ;
clear=true;
first=1;
}

if(temp==num0)
{
if(clear==false)//判断是否点击了符号位
text.setText("");
text.setText(text.getText()+"0");
}

if(temp==num1)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"1");
clear=true;//第二次不在清空（前二句）
}

if(temp==num2)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"2");
clear=true;
}

if(temp==num3)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"3");
clear=true;
}

if(temp==num4)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"4");
clear=true;
}

if(temp==num5)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"5");
clear=true;
}

if(temp==num6)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"6");
clear=true;
}
if(temp==num7)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"7");
clear=true;
}

if(temp==num8)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"8");
clear=true;
}

if(temp==num9)
{
if(clear==false)
text.setText("");
text.setText(text.getText()+"9");
clear=true;
}
if(temp==aa)
{
text.setText(text.getText()+"A");
}
if(temp==bb)
{
text.setText(text.getText()+"B");
}

if(temp==cc)
{
text.setText(text.getText()+"C");
}

if(temp==dd)
{
text.setText(text.getText()+"D");
}

if(temp==ee)
{
text.setText(text.getText()+"E");
}
if(temp==ff)
{
text.setText(text.getText()+"F");
}
if(temp==dian)
{
clickable=true;
for (int i = 0; i < text.getText().length(); i++)
if ('.' == text.getText().charAt(i))
{
clickable=false;
break;
} //第一层判断是否里面含有小数点;

if(clickable==true)//第二坛判断
text.setText(text.getText()+".");

}

try
{
if(temp==jia)
{//加法
qian=Double.parseDouble(text.getText());
fuhao="+";
clear=false;
}
if(temp==jian)
{
qian=Double.parseDouble(text.getText());
fuhao="-";
clear=false;
;

}
if(temp==cheng)
{
qian=Double.parseDouble(text.getText());
fuhao="*";
clear=false;

}
if(temp==chu)
{
qian=Double.parseDouble(text.getText());
fuhao="/";
clear=false;

}
if(temp==deng)
{
double ss=Double.parseDouble(text.getText());
text.setText("");
if(fuhao=="+")
text.setText(qian+ss+"");
if(fuhao=="-")
text.setText(qian-ss+"");
if(fuhao=="*")
text.setText(qian*ss+"");
if(fuhao=="/")
text.setText(qian/ss+"");
clear=false;//要清空前一次的数据
;

}

if(temp==kai)
{
String s = text.getText();
if (s.charAt(0) == '-')
{
text.setText("负数不能开根号");
}
else
text.setText(Double.toString(java.lang.Math.sqrt(Double.parseDouble(text.getText()))));
clear=false;
}

if(temp==diao)
{

if (text.getText().charAt(0) == '0'&&text.getText().length() == 1)
{
text.setText("除数不能为零");
}
else
{
boolean isDec = true;
int i, j, k;
String s = Double.toString(1 / Double.parseDouble(text.getText()));
for (i = 0; i < s.length(); i++)
if (s.charAt(i) == '.')
break;
for (j = i + 1; j < s.length(); j++)
if (s.charAt(j) != '0')
{
isDec = false;
break;
}
if (isDec == true)
{
String stemp = "";
for (k = 0; k < i; k++)
stemp += s.charAt(k);
text.setText(stemp);
}
else
text.setText(s);
}

clear=false;
}
if(temp==qiuyi)
{
text.setText("0");
clear=false;
}
if (temp == fu)
{ //导师，此方法参考书中例子
boolean isNumber = true;
String s = text.getText();
for (int i = 0; i < s.length(); i++)
if (! (s.charAt(i) >= '0' && s.charAt(i) <= '9' || s.charAt(i) == '.' ||
s.charAt(i) == '-'))
{
isNumber = false;
break;
}
if (isNumber == true)
{
//如果当前字符串首字母有'-'号,代表现在是个负数,再按下时,则将首符号去掉
if (s.charAt(0) == '-')
{
text.setText("");
for (int i = 1; i < s.length(); i++)
{
char a = s.charAt(i);
text.setText(text.getText() + a);
}
}
//如果当前字符串第一个字符不是符号，则添加一个符号在首字母处
else
text.setText('-' + s);
}
}

}
catch(Exception eee)
{
System.out.println("运算时,首先输入数字或字符");
text.setText("运算出错");
clear=false;
}

}

class WindowDestroyer extends WindowAdapter
{//退出窗口动作
public void windowClosing(WindowEvent e)
{
System.exit(0);
}
}

class objConversion
{//导师,本进制类参考了CSMD类转换例子

public void objConversion ()
{
}

public String decDec (int decNum)
{//10

String strDecNum = Integer.toString(decNum);

for (int i = strDecNum.length(); i < 3; i++)
{
strDecNum = "0" + strDecNum;
}

// return strDecNum;
return invert (strDecNum, 5);

}

public String decHex (int decNum)
{//10 to 16

String strHexNum = "";
int currentNum = 0;

while (decNum != 0)
{

if (decNum > 15)
{

currentNum = decNum % 16;
decNum /= 16;

}
else
{

currentNum = decNum;
decNum = 0;

}

switch (currentNum)
{

case 15: strHexNum += "F";
break;
case 14: strHexNum += "E";
break;
case 13: strHexNum += "D";
break;
case 12: strHexNum += "C";
break;
case 11: strHexNum += "B";
break;
case 10: strHexNum += "A";
break;
default: strHexNum += Integer.toString(currentNum);
break;

}

}

return invert (strHexNum, 2);

}

public String decOct (int decNum)
{//10 to 8

String strOctNum = "";

while (decNum != 0)
{

if (decNum > 7)
{

strOctNum += Integer.toString(decNum % 8);
decNum /= 8;

}
else
{

strOctNum += Integer.toString(decNum);
decNum = 0;

}

}

return invert (strOctNum, 3);

}

public String decBin (int decNum)
{//10 to 2

String strBinNum = "";

while (decNum != 0)
{

if (decNum > 1)
{

strBinNum += Integer.toString(decNum % 2);
decNum /= 2;

}
else
{

strBinNum += Integer.toString(decNum);
decNum = 0;

}

}

return invert (strBinNum, 8);

}

private String invert (String strNum, int minLength) //转换长度
{

String answer = "";
int length = strNum.length();

if (length < minLength)
{

for (int padding = (minLength - length); padding > 0; padding--)
{
answer += "0";
}

}

for (int i = length; i > 0; i--)
{
answer += strNum.charAt (i - 1);
}

return answer;

}

}

public static void main(String arg[])//产生窗口
{
calculator win = new calculator();
win.setVisible(true);
}

}

⑶ c语言计算器程序源代码

栈操作~
输入的弄成字符串。
如：a+(b+c*(d+e))
先检索“（”入栈，b入栈，+入栈，c入栈，*入栈，后面的不是数字那么“（”入栈，+，入栈，e入栈，
“）”入栈，遇到“）”，出栈操作，直到遇到第一个“（”。
得到字符：d+e,通过算法计算出值D,然后把D入栈。那么栈中的字符为：a+(b+c*D
向后判断一步看是不是乘或除，不是继续向后入栈，是就出栈。
得到c*D，通过算法计算值为C，入栈，那么栈中的字符为：a+(b+C，向后判断，无乘或除运算，继续入栈：“）”，遇到“）”，出栈操作，直到遇到第一个“（”，得到字符串：b+c，算法计算值为B，入栈
栈中字符串为：a+B 字符串结束，出栈操作计算出a+B,值。
如果字符串的式子很长的话，就反复的入栈出栈计算。
思路是这样的......
关于COS，SIN类的关键字，也是上面的思路，
(入栈，直到遇到)出栈，先计算出括号里的，然后后退一步判断前面的是乘除或者关键字，
如：sin(0.1+0.2)
操作得出sin0.3然后判断前面的是不是关键字，是那句计算sin0.3。
但是遇到关键字的时候不是一个一个字符在一起的，你可以入栈的时候判断是不是字母，是字母，那么入栈直到不是字母为止，出栈判断关键字也是一样......
不明白的继续问~

⑷ 如何用VC编写一个计算器程序

#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
#include<math.h>
#define N 26 /*根据自己的需要，可以定义要进行运算的数字的最大个数*/
int main(void)
{
int i,j,k;
double num[N];
char sym[N],str[12];
loop1:
printf("Input a calculation method like 1+2^3-4*5/10=↙\nPlease:"); /*可以进行加、减、乘、除、乘方的运算*/
for(i=0;i<N;i++)
{
scanf("%lf%c",&num[i],&sym[i]); /*num[N]用来存储运算数字，sym[N]用来存储运算符号*/
if(sym[i]=='=') break; /*当出现等号时，表示计算式结束*/
}
for(j=0;j<=i;j++)
if(sym[j]=='^') /*判断优先级中的乘方，它是首先要处理的*/
{
if(num[j]==0&&num[j+1]==0) {printf("Input error!\n");goto loop2;} /*指数为零时，底数不为零。否则，进入标记位置*/
else num[j]=pow(num[j],num[j+1]); /*将本次出现的乘方运算结果，放在前一项中*/
for(k=j;k<i;k++)
{
sym[k]=sym[k+1]; /*依次将后面的符号替换到前面，因为符号中有"="，所以要多替换1次*/
if(k!=i-1) num[k+1]=num[k+2]; /*依次将后面的数字替换到前面*/
}
j--,i--; /*"j--"表示下一次从本次的位置开始继续判断是否为优先级中的乘方，因为本次位置替换后的符号仍然可能是"^"，
"i--"表示下次处理的数字将减少1个*/
}
for(j=0;j<=i;j++)
{
if(sym[j]=='*') /*当计算式中没有"^"时，将开始判断优先级中的"*"，它是其次要处理的*/
{
num[j]=num[j]*num[j+1]; /*将本次出现的乘法运算结果，放在前一项中*/
for(k=j;k<i;k++)
{
sym[k]=sym[k+1]; /*依次将后面的符号替换到前面，因为符号中有"="，所以要多替换1次*/
if(k!=i-1) num[k+1]=num[k+2]; /*依次将后面的数字替换到前面*/
}
j--,i--; /*"j--"表示下一次从本次的位置开始继续判断是否为优先级中的乘法，因为本次位置替换后的符号仍然可能是"*"，
"i--"表示下次处理的数字将减少1个*/
}
if(sym[j]=='/') /*当计算式中没有"^"时，将开始判断优先级中的"/"，它也是其次要处理的*/
{
if(num[j+1]==0) {printf("Input error!\n");goto loop2;} /*分母不为零。否则，进入标记位置*/
else num[j]=num[j]/num[j+1]; /*将本次出现的除法运算结果，放在前一项中*/
for(k=j;k<i;k++)
{
sym[k]=sym[k+1]; /*依次将后面的符号替换到前面，因为符号中有"="，所以要多替换1次*/
if(k!=i-1) num[k+1]=num[k+2]; /*依次将后面的数字替换到前面*/
}
j--,i--; /*"j--"表示下一次从本次的位置开始继续判断是否为优先级中的除法，因为本次位置替换后的符号仍然可能是"/"，
"i--"表示下次处理的数字将减少1个*/
}
}
for(j=0;j<=i;j++)
switch(sym[j]) /*最后只剩"+"和"-"了，将每次运算的结果放在后一项中*/
{
case '+':num[j+1]=num[j]+num[j+1];break;
case '-':num[j+1]=num[j]-num[j+1];break;
case '=':break;
}
gcvt(num[i],12,str); /*将浮点数转换成字符串*/
for(j=0;j<12;j++)
if(str[j]=='.'&&!str[j+1]) str[j]=str[j+1]; /*当小数点后紧接字符串结束标志时，原本应该输出如"5."，处理后为"5"*/
printf("Result=%s\n",str); /*计算式的结果，最终存放在最后一项的字符串中*/
loop2:
printf("Continue(y/n)?"); /*是否继续，y表示继续，n表示退出*/
switch(getch())
{
case 'y':{system("cls");goto loop1;} /*点击y，清空屏幕，返回标记位置*/
case 'n':exit(0); /*点击n，退出程序*/
default :exit(0); /*点击其它键，也退出程序*/
}
getch();
return 0;
}

说明:必须将扩展名设置为c，若是cpp，将无法通过系统的编译。

⑸ C语言 编译计算器可以分别计算加减乘除

#include<stdio.h>
#defineCLR_INTPUTwhile(getchar()!='
')
intmain(void)
{
charch;
floatnum1,num2;
doublenum;
printf("输入方式为(例n*n)
");
while(1)
{

while(scanf("%f",&num1)!=1)//确保输入数据正确
{
printf("输入有误,请重新输入第一个数
");
CLR_INTPUT;
}
getchar();//清除空格符

while(scanf("%c",&ch)==1)
{

if(ch!='+'&&ch!='-'&&ch!='*'&&ch!='/')
{
printf("输入有误,请重新输入运算操作
");
CLR_INTPUT;
continue;
}
break;
}
getchar();//清除空格符

while(scanf("%f",&num2)!=1)
{
printf("输入有误,请重新输入第二个数
");
CLR_INTPUT;
}

CLR_INTPUT;//清除输入缓冲

switch(ch)
{
case'+':num=num1+num2;
break;
case'-':num=num1-num2;
break;
case'*':num=num1*num2;
break;
case'/':num=num1/num2;
break;
default:printf("输入运算有误
");
}
printf("%.2f%c%.2f=%.4lf
",num1,ch,num2,num);
}
return0;
}
程序还是有些BUG，对用户输入出错提示的不够。

⑹ 求一个C语言编译计算器的程序！

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
double f(double a[100],char b[100],int la,int lb)
{
int i,j,k;
for(i=0;i<lb;i++)
{
if(b[i]==’*’)
{
a[i]=a[i]*a[i+1];
for(j=i;j<lb-1;j++)
b[j]=b[j+1];
for(j=i+1;j<la-1;j++)
a[j]=a[j+1];
la--;
lb--;
i--;
}
else if(b[i]==’/’)
{
a[i]=a[i]/a[i+1];
for(j=i;j<lb-1;j++)
b[j]=b[j+1];
for(j=i+1;j<la-1;j++)
a[j]=a[j+1];
la--;
lb--;
i--;
}
}
for(i=0;i<lb;i++)
{
if(b[i]==’+’)
{
a[i]=a[i]+a[i+1];
for(j=i;j<lb-1;j++)
b[j]=b[j+1];
for(j=i+1;j<la-1;j++)
a[j]=a[j+1];
la--;
lb--;
i--;
}
else if(b[i]==’-’)
{
a[i]=a[i]-a[i+1];
for(j=i;j<lb-1;j++)
b[j]=b[j+1];
for(j=i+1;j<la-1;j++)
a[j]=a[j+1];
la--;
lb--;
i--;
}
}

return a[0];
}
main()
{
char b[100],c[100],y[100];
double a[100],s,t,x[100];
int i,j,k,la,lb,l,ld,le,d[100],e[100],g[100],lx,ly;
while(gets(c))
{
i=0;j=0;t=1;l=0;
for(k=0;k<100;k++)
a[k]=0;
s=0;
for(k=0;c[k];k++)
{
if(c[k]>=’0’&&c[k]<=’9’)
if(t==1)
{
s=s*10+c[k]-’0’;

}
else
{
s=s+(c[k]-’0’)*t;
t=t/10;
}
else if(c[k]==’.’)
t=0.1;
else if(c[k]==’+’||c[k]==’-’||c[k]==’*’||c[k]==’/’)
{
b[i]=c[k];
a[i++]=s;

s=0;
t=1;
}
else if(c[k]==’(’)
{

g[j++]=i;

}
else if(c[k]==’)’)
{

e[l++]=i;

}
}
a[i++]=s;
ld=j;
le=l;
la=i;

lb=la-1;
for(i=0;i<ld;i++)
d[i]=g[ld-i-1];

for(i=0;i<ld;i++)
{
for(j=0,k=d[i];k<e[i];k++,j++)
{
x[j]=a[k];
y[j]=b[k];
}
x[j++]=a[k];
lx=j;
ly=j-1;

a[(d[i])]=f(x,y,lx,ly);

k=e[i]-d[i];
for(j=d[i]+1;j<la-1;j++)
{
a[j]=a[j+k];
b[j]=b[j+k];
}
a[j]=a[j+k];
la=la-k;
lb=lb-k;
for(j=i+1;j<ld;j++)
e[j]=e[j]-k;

}
s=f(a,b,la,lb);

printf("s=%lf\n",s);

}
}

//这是c语言表达式求值程序如输入（1+3*5*（2+6））就会输出正确结果

⑺ 哪位高手帮忙用C++做一个求复杂表达式的计算器~

#include "iostream"
#include "math.h"
#include "cstring"
using namespace std;

const int MaxSize=300;

int trans(char *exp, char postexp[]);
double compvalue(char *postexp);

int main(int argc, char* argv[])
{
char exp[300],postexp[400];
cout<<"================================================================================";
cout<<"================================================================================";
cout<<" 欢迎你的到来"<<endl;
cout<<" 本程序为求复杂表达式的值的计算器"<<endl;
cout<<"================================================================================";
cout<<"================================================================================";

while (1)
{ cout <<"请输入一个表达式:(按0结束本程序)\n";
cin>>exp;
if (strcmp(exp,"0")==0)
return 0;

if (trans(exp,postexp)==1)
{ double res=compvalue(postexp);
cout<<"="<<res<<endl;
}
}
return 0;
}

int trans(char *exp, char postexp[])
/*将算术表达式exp转换成后缀表达式postexp */
{ struct
{ char data[MaxSize]; /*存放运算符*/
int top; /*栈指针*/
} op; /*定义运算符栈*/

int i=0; /* i作为postexp的下标*/
int dh=1; /* dh==1表示是负号 */
op.top=-1;
while (*exp!='\0') /* exp表达式未扫描完时循环 */
{ switch(*exp)
{ case '(': /*判定为左括号*/
op.top++;op.data[op.top]=*exp; dh=1;
exp++;break;
case ')': /*判定为右括号*/
while (op.data[op.top]!='(')
{ postexp[i]=op.data[op.top];
op.top--; i++;
}
op.top--; exp++; dh=0; break;
case '+':
case '-': /*判定为加或减号*/
if (dh==1) /* +,-是正负号 */
{ if (*exp=='-')
op.top++;op.data[op.top]='@';
exp++; break;
}
while (op.top!=-1 && op.data[op.top]!='(')
{ postexp[i]=op.data[op.top];
op.top--; i++;
}
op.top++;op.data[op.top]=*exp; exp++; dh=0; break;
case '*':
case '/': /*判定为'*'或'/'号*/
while (op.data[op.top]=='*' || op.data[op.top]=='/'|| op.data[op.top]=='s')
{ postexp[i]=op.data[op.top];
op.top--; i++;
}
op.top++;op.data[op.top]=*exp; exp++; dh=0; break;
case '^':
while (op.data[op.top]=='^')
{ postexp[i]=op.data[op.top];
op.top--;i++;
}
op.top++;op.data[op.top]=*exp;exp++;dh=0;break;
case '%':
while (op.data[op.top]=='%')
{ postexp[i]=op.data[op.top];
op.top--;i++;
}
op.top++;op.data[op.top]=*exp;exp++;dh=0;break;
case ' ': exp++; break; /*过滤掉空格*/
case 's':
case 'S':
if((*(exp+1)=='i' || *(exp+1)=='I')&&(*(exp+2)=='n' || *(exp+2)=='N'))
{ op.top++;op.data[op.top]='s';
exp+=3; dh=0;
break;
}
else
if((*(exp+1)=='q'|| *(exp+1)=='Q')&&(*(exp+2)=='r' || *(exp+2)=='R')&&(*(exp+3)=='t' || *(exp+3)=='T'))
{ op.top++;op.data[op.top]='q';
exp+=4;dh=0;
break;
}
else { printf("\n有错误符号s"); return 0; }

case 'c':
case 'C':
if((*(exp+1)=='o' || *(exp+1)=='O')&&(*(exp+2)=='s' || *(exp+2)=='S'))
{ op.top++;op.data[op.top]='c';
exp+=3; dh=0;
break;
}
else { printf("\n有错误符号s"); return 0; }
case 'T':
case 't':
if((*(exp+1)=='a'|| *(exp+1)=='A')&&(*(exp+2)=='n' || *(exp+2)=='N'))
{ op.top++;op.data[op.top]='t';
exp+=3;dh=0;
break;
}
else { printf("\n有错误符号s"); return 0; }
case 'e':
case 'E':
if((*(exp+1)=='x'|| *(exp+1)=='X')&&(*(exp+2)=='p' || *(exp+2)=='P'))
{ op.top++;op.data[op.top]='e';
exp+=3;dh=0;
break;
}
else { printf("\n有错误符号s"); return 0; }
case 'a':
case 'A':
if((*(exp+1)=='b'|| *(exp+1)=='B')&&(*(exp+2)=='s' || *(exp+2)=='S'))
{ op.top++;op.data[op.top]='a';
exp+=3;dh=0;
break;
}
else { printf("\n有错误符号s"); return 0; }
case 'l':
case 'L':
if((*(exp+1)=='o'|| *(exp+1)=='O')&&(*(exp+2)=='g' || *(exp+2)=='G'))
{ op.top++;op.data[op.top]='g';
exp+=3;dh=0;
break;
}
else
if((*(exp+1)=='n'|| *(exp+1)=='N'))
{ op.top++;op.data[op.top]='n';
exp+=2;dh=0;
break;
}
else { printf("\n有错误符号s"); return 0; }
default:
while (*exp>='0' && *exp<='9') /*判定为数字*/
{ postexp[i]=*exp;i++;
exp++;
}
if (*exp=='.')
{ postexp[i]='.'; i++; exp++;
while (*exp>='0' && *exp<='9') /*判定为数字*/
{ postexp[i]=*exp;i++;
exp++;
}
}
postexp[i]='#'; i++; dh=0;/*用#标识一个数值串结束*/
}
}
while (op.top!=-1) /*此时exp扫描完毕,栈不空时循环*/
{ postexp[i]=op.data[op.top];
i++; op.top--;
}
postexp[i]='\0'; /*给postexp表达式添加结束标识*/
return 1;
}

double compvalue(char *postexp) /*计算后缀表达式的值*/
{ struct
{ float data[MaxSize]; /*存放数值*/
int top; /*栈指针*/
} st; /*定义数值栈*/

double d,x;

st.top=-1;
while (*postexp!='\0') /* postexp字符串未扫描完时循环*/
{ switch (*postexp)
{
case '+':st.data[st.top-1]=st.data[st.top-1]+st.data[st.top];
st.top--;break;
case '-':st.data[st.top-1]=st.data[st.top-1]-st.data[st.top];
st.top--;break;
case '*':st.data[st.top-1]=st.data[st.top-1]*st.data[st.top];
st.top--;break;
case '/':
if (st.data[st.top]!=0)
st.data[st.top-1]=st.data[st.top-1]/st.data[st.top];
else
{ printf("\n\t除数不能为零!\n");
return 0;
}
st.top--;break;
case '^':st.data[st.top-1]=pow(st.data[st.top-1],st.data[st.top]);
st.top--;break;
case '%':st.data[st.top-1]=fmod(st.data[st.top-1],st.data[st.top]);
st.top--;break;
case '@':st.data[st.top]=-(st.data[st.top]);
break;
case 's':st.data[st.top]=sin(st.data[st.top]);
break;
case 'c':st.data[st.top]=cos(st.data[st.top]);
break;
case 'q':
if(st.data[st.top]>=0)
st.data[st.top]=sqrt(st.data[st.top]);
else
{ printf("\n\t开方内的数不能小于零!\n");
return 0;
}
break;
case 'e':st.data[st.top]=exp(st.data[st.top]);
break;
case 't':st.data[st.top]=tan(st.data[st.top]);
break;
case 'a':st.data[st.top]=abs(st.data[st.top]);
break;
case 'g':
if(st.data[st.top]>0)
st.data[st.top]=log10 (st.data[st.top]);
else
{ printf("\n\tlog10内的数不能小于等于零!\n");
return 0;
}
break;
case 'n':
if(st.data[st.top]>0)
st.data[st.top]=log(st.data[st.top]);
else
{ printf("\n\tln内的数不能小于等于零!\n");
return 0;
}
break;
default:
d=0; /*将数字字符转换成数值存放到d中*/
while (*postexp>='0' && *postexp<='9') /*为数字字符*/
{ d=10*d+(*postexp-'0');
postexp++;
}
x=0.1;
if (*postexp=='.')
{ postexp++;
while (*postexp>='0' && *postexp<='9') /*为数字字符*/
{ d=d+x*(*postexp-'0');
x*=0.1;
postexp++;
}
}
st.top++; st.data[st.top]=d;
}
postexp++;
}
return st.data[st.top];
}

⑻ C# 计算器编程

这个就要用到编译器中对语法分析的原理：
你没有发现在编译器中这样的表达式是可以正确运算的吗？
要实现对表达式进行词法，语法分析是知道以下几点
1，要对数据结构了解，简单的计算器程序使用两个栈(数据结构中的栈)即可以实现。
2，复杂的计算器程序要使用到语法树(数据结构中的二叉树)来实现。
3，对词法分析和语法分析很了解。词法分析就是将你的表达式转换成一个一个的字符和数字，语法分析就是将表达式转换成语法树。
4，对表达式的前缀，中缀，后缀了解。 编译系统是总样来确定优先级的呢？ 就是通过对中缀表达式转换成后缀表达式。 在后缀表达式中可以不用管表达式的优先级问题。
5，表达式的存储：即这个“1+2X3+4/2”表达式是以什么样的方法存储到内存中，如果是以字符串，那么在词法分析时，要总样将如 1 ,这个字符转换成数字型1，这也是一个问题。
6，在进行计算时，是否要先检查用户输入的表达式是否合法，最好有一些智能的判断，以免在用户输入时没有注意输入错误的表达式，这样你也给计算出结果来，这就会误导用户。
7，建议你先编写简单的计算器，像windows下的标准型计算器，它的优先级问题要求用户自己解决。 你想编写的这种计算器是高级计算器，难度不小。

⑼ 一个计算器怎么用C语言编译

#include<stdio.h>
int main() {
double num1 = 0; //输入1
double num2 = 0; //输入2
char ch; //操作
double ret = 0; //结果 printf( "输入第一个数:" );
scanf( "%lf", &num1 );
printf( "输入第二个数:" );
scanf( "%lf", &num2 );
printf( "操作[+ - * /]:" );
getchar();
scanf( "%c", &ch ); switch( ch ) {
case '+':
ret = num1 + num2;
break;
case '-':
ret = num1 - num2;
break;
case '*':
ret = num1 * num2;
break;
case '/':
ret = num1 / num2;
break;
default:
break;
}
printf( "结果:%.2lf\n", ret ); return 0;
}