編譯復雜的計算器程序

⑴ 用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;
}