用編譯器思想做計算器

『壹』 用java編譯一個計算器的基本思想是什麼

首先你得先畫一個界面，先把界面實現出來，用Swing或者AWT；
然後就是書寫監聽類，每個按鈕都得有監聽的類，一般是內部類；
加減乘除的監聽好寫，關鍵是多位運算和連續運算，得想好是什麼時候顯示結果，比如說我輸入一個數字，再點擊按鈕時如果是運算按鍵，那顯示不動，如果還是數字鍵，那就要變成兩位，這些考慮清楚了就差不多了，祝你成功

『貳』 用C語言設計一個簡單計算器的課程設計(希望能盡可能的詳細,多一些)

//名字記不太清了，這個叫遞歸下降演算法，但這個演算法肯定是首先在編譯原理中的，主要用在
//各種編譯器中。就是現掃描整個表達式字元串，把其中的運算符找出來，判斷它們的優先順序
//然後按從左到右的順序先計算把優先順序低的運算符和它兩邊的數據壓入，這樣循環做過以後
//再從頭取出一個一個計算，羨派表達式的結構類似與二叉樹，遍歷二叉樹後把結果存在連表中供
//計算。你這個程序問題好像比較多啊。用的數據結構類型和函數名根本就不配套
#include <stdio.h>
struct s_node //節點結構體
{
int data;

struct s_node *next;
};
typedef struct s_node s_list;
typedef s_list *link;
link operator=NULL;
link operand=NULL;

link push(link stack,int value) //向螞猜鏈表添加數據
{
link newnode;

newnode=(link) malloc(sizeof(s_list));
if(!newnode)
{
printf("\nMemory allocation failure!!!");
return NULL;
}
newnode->data=value;
newnode->next=stack;
stack=newnode;
return stack;
}

link pop(link stack,int *value) //從鏈表取出數據
{
link top;
if(stack !=NULL)
{
top=stack;
stack=stack->next;
*value=top->data;
free(top);
return stack;
}
else
*value=-1;
}

int empty(link stack) //判斷鏈表是否為空
{
if(stack==NULL)
return 1;
else
return 0;

}

int is_operator(char operator) //判斷是否是運算符號
{
switch (operator)
{
case '+': case '-': case '*': case '/': return 1;
default:return 0;
}
}

int priority(char operator) //判斷運算符優先順序
{
switch(operator)
{
case '+': case '-' : return 1;
case '*': case '/' : return 2;
default: return 0;
}
}

int two_result(int operator,int operand1,int operand2) //計算數值，計算器的核心
{
switch(operator)
{
case '+':return(operand2+operand1);
case '-':return(operand2-operand1);
case '*':return(operand2*operand1);
case '/':return(operand2/operand1);
}
}

void main()
{
char expression[50];
int position=0;
int op=0;
int operand1=0;
int operand2=0;
int evaluate=0;

printf("\nPlease input the inorder expression:");
gets(expression);

while(expression[position]!='\0'悶派型&&expression[position]!='\n')
{
if(is_operator(expression[position]))
{
if(!empty(operator))
while(priority(expression[position])<= priority(operator->data)&&
!empty(operator))
{
operand=pop(operand,&operand1);
operand=pop(operand,&operand2);
operator=pop(operator,&op);
operand=push(operand,two_result(op,operand1,operand2));
}
operator=push(operator,expression[position]);
}
else
operand=push(operand,expression[position]-48);
position++;
}
while(!empty(operator))
{
operator=pop(operator,&op);
operand=pop(operand,&operand1);
operand=pop(operand,&operand2);

operand=push(operand,two_result(op,operand1,operand2));
}
operand=pop(operand,&evaluate);
printf("The expression [%s] result is '%d' ",expression,evaluate);
getch();
}

『叄』 JAVA怎麼用面向對象思想寫計算器

//frame版程序源代碼如下，疏漏之處，望批評指正。
//數字分組沒有編寫，科學型計算器沒有編寫，其他已經完善。
import java.awt.*;
import java.lang.*;
import javax.swing.*;
import javax.swing.event.*;
import java.awt.event.*;
import java.text.DecimalFormat;public class Calculator implements ActionListener { // 導入動作監聽介面
// 設計面板中的單位
JFrame frame; JTextField textAnswer; JPanel panel, panel1, panel2, panel3; JMenuBar mainMenu; JTextField textMemory; JLabel labelMemSpace; // labelMemSpace單純做擺設，控制面板的形狀 JButton buttonBk, buttonCe, buttonC; JButton button[]; JButton buttonMC, buttonMR, buttonMS, buttonMAdd; JButton buttonDot, buttonAddAndSub, buttonAdd, buttonSub, buttonMul,
buttonDiv, buttonMod; JButton buttonSqrt, buttonDao, buttonEqual; JMenu editMenu, viewMenu, helpMenu; JMenuItem Item, pasteItem, tItem, sItem, numberGroup, topHelp,
aboutCal; DecimalFormat df; // 設置數據輸出精度 boolean clickable; // 控制當前能否按鍵 double memoryd; // 使用內存中存儲的數字 int memoryi; double vard, answerd; // 用來保存double型數據的中間值(vard)和最後結果(answerd) short key = -1, prekey = -1; // key用來保存當前進行何種運算,prekey用來保存前次進行何種運算 String ; // 做復制用 JTextArea help; // 幫助 JScrollPane scrollHelp; // 構造函數
public Calculator() {
clickable = true;
answerd = 0;
frame = new JFrame("計算器");
df = new DecimalFormat("0.##############"); // 設置數據輸出精度(對於double型值)
textAnswer = new JTextField(15);
textAnswer.setText("");
textAnswer.setEditable(false);
textAnswer.setBackground(new Color(255, 255, 255));
panel = new JPanel();
frame.getContentPane().add(panel);
panel1 = new JPanel();
panel2 = new JPanel();
panel.setLayout(new BorderLayout());
// 設計整個面板
mainMenu = new JMenuBar();
editMenu = new JMenu("編輯(E)");
viewMenu = new JMenu("查看(V)");
helpMenu = new JMenu("幫助(H)");
Item = new JMenuItem(" 復制(C) Ctrl+C");
Item.addActionListener(this);
pasteItem = new JMenuItem(" 粘貼(V) Ctrl+V");
pasteItem.addActionListener(this);
editMenu.add(Item);
editMenu.add(pasteItem);
tItem = new JMenuItem("●標准型(T)");
tItem.addActionListener(this);
sItem = new JMenuItem(" 科學型(S)");
sItem.addActionListener(this);
numberGroup = new JMenuItem(" 數字分組(I)");
numberGroup.addActionListener(this);
viewMenu.add(tItem);
viewMenu.add(sItem);
viewMenu.add(numberGroup);
topHelp = new JMenuItem(" 幫助主題(H)");
topHelp.addActionListener(this);
help = new JTextArea(5, 20);
scrollHelp = new JScrollPane(help);
help.setEditable(false);
help.append("執行簡單計算\n");
help.append("1. 鍵入計算的第一個數字。\n");
help.append("2. 單擊「+」執行加、「-」執行減、「*」執行乘或「/」執行除。\n");
help.append("3. 鍵入計算的下一個數字。\n");
help.append("4. 輸入所有剩餘的運算符和數字。\n");
help.append("5. 單擊「=」。\n");
aboutCal = new JMenuItem(" 關於計算器(A)");
aboutCal.addActionListener(this);
helpMenu.add(topHelp);
helpMenu.add(aboutCal);
mainMenu.add(editMenu);
mainMenu.add(viewMenu);
mainMenu.add(helpMenu);
panel.add(mainMenu, BorderLayout.NORTH);
panel.add(textAnswer, BorderLayout.CENTER);
panel.add(panel1, BorderLayout.SOUTH);
panel1.setLayout(new BorderLayout());
textMemory = new JTextField(3);
textMemory.setEditable(false);
textMemory.setBackground(new Color(217, 217, 217));
labelMemSpace = new JLabel(" ");
buttonBk = new JButton("Backspace");
buttonBk.setForeground(new Color(255, 0, 0));
buttonCe = new JButton("CE");
buttonCe.setForeground(new Color(255, 0, 0));
buttonC = new JButton("C");
buttonC.setForeground(new Color(255, 0, 0));
buttonBk.addActionListener(this);
buttonCe.addActionListener(this);
buttonC.addActionListener(this);
panel1.add(panel2, BorderLayout.NORTH);
panel2.setLayout(new FlowLayout(FlowLayout.RIGHT));
panel2.add(textMemory);
panel2.add(labelMemSpace);
panel2.add(buttonBk);
panel2.add(buttonCe);
panel2.add(buttonC);
panel3 = new JPanel();
panel1.add(panel3, BorderLayout.CENTER);
button = new JButton[10];
for (int i = 0; i < button.length; i++) {
button[i] = new JButton(Integer.toString(i));
button[i].setForeground(new Color(0, 0, 255));
}
buttonMC = new JButton("MC");
buttonMC.setForeground(new Color(255, 0, 0));
buttonMR = new JButton("MR");
buttonMR.setForeground(new Color(255, 0, 0));
buttonMS = new JButton("MS");
buttonMS.setForeground(new Color(255, 0, 0));
buttonMAdd = new JButton("M+");
buttonMAdd.setForeground(new Color(255, 0, 0));
buttonDot = new JButton(".");
buttonDot.setForeground(new Color(0, 0, 255));
buttonAddAndSub = new JButton("+/-");
buttonAddAndSub.setForeground(new Color(0, 0, 255));
buttonAdd = new JButton("+");
buttonAdd.setForeground(new Color(255, 0, 0));
buttonSub = new JButton("-");
buttonSub.setForeground(new Color(255, 0, 0));
buttonMul = new JButton("*");
buttonMul.setForeground(new Color(255, 0, 0));
buttonDiv = new JButton("/");
buttonDiv.setForeground(new Color(255, 0, 0));
buttonMod = new JButton("%");
buttonMod.setForeground(new Color(0, 0, 255));
buttonSqrt = new JButton("sqrt");
buttonSqrt.setForeground(new Color(0, 0, 255));
buttonDao = new JButton("1/x");
buttonDao.setForeground(new Color(0, 0, 255));
buttonEqual = new JButton("=");
buttonEqual.setForeground(new Color(255, 0, 0));
// 將所有行為與監聽綁定
panel3.setLayout(new GridLayout(4, 6));
panel3.add(buttonMC);
buttonMC.addActionListener(this);
panel3.add(button[7]);
button[7].addActionListener(this);
panel3.add(button[8]);
button[8].addActionListener(this);
panel3.add(button[9]);
button[9].addActionListener(this);
panel3.add(buttonDiv);
buttonDiv.addActionListener(this);
panel3.add(buttonSqrt);
buttonSqrt.addActionListener(this);
panel3.add(buttonMR);
buttonMR.addActionListener(this);
panel3.add(button[4]);
button[4].addActionListener(this);
panel3.add(button[5]);
button[5].addActionListener(this);
panel3.add(button[6]);
button[6].addActionListener(this);
panel3.add(buttonMul);
buttonMul.addActionListener(this);
panel3.add(buttonMod);
buttonMod.addActionListener(this);
panel3.add(buttonMS);
buttonMS.addActionListener(this);
panel3.add(button[1]);
button[1].addActionListener(this);
panel3.add(button[2]);
button[2].addActionListener(this);
panel3.add(button[3]);
button[3].addActionListener(this);
panel3.add(buttonSub);
buttonSub.addActionListener(this);
panel3.add(buttonDao);
buttonDao.addActionListener(this);
panel3.add(buttonMAdd);
buttonMAdd.addActionListener(this);
panel3.add(button[0]);
button[0].addActionListener(this);
panel3.add(buttonAddAndSub);
buttonAddAndSub.addActionListener(this);
panel3.add(buttonDot);
buttonDot.addActionListener(this);
panel3.add(buttonAdd);
buttonAdd.addActionListener(this);
panel3.add(buttonEqual);
buttonEqual.addActionListener(this);
frame.setDefaultCloseOperation(frame.EXIT_ON_CLOSE);
frame.pack();
frame.show();
} // 設置各個按鈕行為
public void actionPerformed(ActionEvent event) {
boolean sign = false; // 判斷是否是double型數參與運算，是為true，不是為false
Object temp = event.getSource();
try {
// 如果按下數據按鈕，將按下的按鈕代表的數據插入的當前文本框字元串之後
for (int i = 0; i <= 9; i++)
if (temp == button[i] && clickable == true)
textAnswer.setText(textAnswer.getText()
+ Integer.toString(i));
// 按下'.'按鈕時，判斷當前文本框內字元串中含不含'.'，如果已含，則不允許再插入'.'
if (temp == buttonDot && clickable == true) {
boolean isDot = false;
if (textAnswer.getText().length() == 0)
isDot = true;
for (int i = 0; i < textAnswer.getText().length(); i++)
if ('.' == textAnswer.getText().charAt(i)) {
isDot = true;
break;
}
if (isDot == false)
textAnswer.setText(textAnswer.getText() + ".");
}
if ((temp == buttonAdd || temp == buttonSub || temp == buttonMul || temp == buttonDiv)
&& clickable == true) {
// '+'操作
if (temp == buttonAdd) {
switch (prekey) {
case 0:
answerd += Double.parseDouble(textAnswer.getText());
break;
case 1:
answerd -= Double.parseDouble(textAnswer.getText());
break;
case 2:
answerd *= Double.parseDouble(textAnswer.getText());
break;
case 3:
if (Double.parseDouble(textAnswer.getText()) == 0) {
textAnswer.setText("除數不能為零");
clickable = false;
} else
answerd /= Double.parseDouble(textAnswer.getText());
break;
default:
answerd = Double.parseDouble(textAnswer.getText());
}
textAnswer.setText("");
prekey = key = 0;
}
// '-'操作
if (temp == buttonSub) {
switch (prekey) {
case 0:
answerd += Double.parseDouble(textAnswer.getText());
break;
case 1:
answerd -= Double.parseDouble(textAnswer.getText());
break;
case 2:
answerd *= Double.parseDouble(textAnswer.getText());
break;
case 3:
if (Double.parseDouble(textAnswer.getText()) == 0) {
textAnswer.setText("除數不能為零");
clickable = false;
} else
answerd /= Double.parseDouble(textAnswer.getText());
break;
default:
answerd = Double.parseDouble(textAnswer.getText());
}
textAnswer.setText("");
prekey = key = 1;
}
// '*'操作
if (temp == buttonMul) {
switch (prekey) {
case 0:
answerd += Double.parseDouble(textAnswer.getText());
break;
case 1:
answerd -= Double.parseDouble(textAnswer.getText());
break;
case 2:
answerd *= Double.parseDouble(textAnswer.getText());
break;
case 3:
if (Double.parseDouble(textAnswer.getText()) == 0) {
textAnswer.setText("除數不能為零");
clickable = false;
} else
answerd /= Double.parseDouble(textAnswer.getText());
break;
default:
answerd = Double.parseDouble(textAnswer.getText());
}
textAnswer.setText("");
prekey = key = 2;
}
// '/'操作
if (temp == buttonDiv) {
switch (prekey) {
case 0:
answerd += Double.parseDouble(textAnswer.getText());
break;
case 1:

『肆』 C語言編一個計算器的思想

表達式求值，說起來很復雜，我有源代碼，你自己研究研究

#include<stdio.h>
#include<stdlib.h>
#define MaxSize 99
void translate(char str[],char exp[]) /*將算術表達式轉換成後綴表達式*/
{
struct
{
char data[MaxSize];
int top; /*top為棧頂*/
}op; /*定義一個含data和top的結構體*/
char ch;
int i = 0,t = 0;
op.top = -1;
ch = str[i]; /*將str的每一個數轉換成ch*/
i++;
while(ch != '\0') /*ch對應不同的符號的時候對應的轉換情況*/
{
switch(ch)
{
case '(': /*當是（的時候，將此括弧存入棧op*/
op.top++;op.data[op.top]=ch;
break;
case ')':
while(op.data[op.top] != '(') /*括弧內的轉換優先順序最高，故先提取表達式*/
{
exp[t]=op.data[op.top];
op.top--;
t++;
}
op.top--;
break;
case '+':
case '-':
while(op.top != -1&&op.data[op.top] != '(')
{
exp[t] = op.data[op.top];
op.top--;
t++;
}
op.top++; /*恢復可插入位置*/
op.data[op.top] = ch;
break;
case '*':
case '/':
while(op.top == '/'||op.top == '*') /*優先順序*/
{
exp[t] = op.data[op.top];
op.top--;
t++;
}
op.top++;
op.data[op.top] = ch;
break;
case ' ': /*忽略空格，排除誤操作*/
break;
default:
while(ch >= '0'&&ch <= '9')
{
exp[t] = ch;t++;
ch = str[i];i++;
}
i--;
exp[t] = '#'; /*分隔操作數，為了美觀，也為了以後好分隔操作數，呵呵*/
t++;
}
ch = str[i];
i++;
}
while(op.top != -1) /*得到剩下的部分*/
{
exp[t] = op.data[op.top];
t++;
op.top--;
}
exp[t] = '\0'; /*表達式結束*/
}
float cal_value(char exp[])
{
struct
{
float data[MaxSize];
int top;
}st; /*操作數棧*/
float d;
char ch;
int t = 0;
st.top = -1;
ch = exp[t];
t++;
while(ch != '\0')
{
switch(ch) /*運算主體*/
{
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除0是錯誤的");
}
st.top--;
break;
default:
d=0;
while(ch >= '0'&&ch <= '9') /*從後綴表達式中獲取操作數，#作用在此體現*/
{
d = 10*d+ch-'0';
ch = exp[t];
t++;
}
st.top++;
st.data[st.top] = d;
}
ch = exp[t];
t++;
}
return st.data[st.top];
}
int main() /*可以提到前面去*/
{
char str[MaxSize],exp[MaxSize]; /*str為算術表達式,exps為後綴表達式*/
printf("請輸入一個求值表達式\n");
printf("表達式:");
gets(str); /*輸入一個算術表達式*/
printf("原表達式是:%s\n",str);
translate(str,exp); /*將算術表達式轉換成後追表達式*/
printf("後綴表達式：%s\n",exp);
printf("計算結果:%g\n",cal_value(exp));/*通過後綴表達式來求值*/
system("pause");
return 0;
}

『伍』 用Java中的面向思維思想編寫一個計算器類，可以實現兩個數的加，減，乘，除運算，寫出編程的代碼

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
class Counter extends WindowAdapter
{
static JFrame f=new JFrame("計算器");
static JTextField text1=new JTextField("0.");
static String source="";
static String cal="";
static String object="";
static boolean flag=false;
static boolean flag1=true;
static boolean flag2=false;
public void init()
{
try
{
Container c=f.getContentPane();
JPanel pan1=new JPanel();
JButton b1=new JButton("1");
JButton b2=new JButton("2");
JButton b3=new JButton("3");
JButton b4=new JButton("4");
JButton b5=new JButton("5");
JButton b6=new JButton("6");
JButton b7=new JButton("7"彎吵);
JButton b8=new JButton("8");
JButton b9=new JButton("9");
JButton b0=new JButton("者神0");
JButton b11=new JButton("+");
JButton b12=new JButton("-");
JButton b13=new JButton("*");
JButton b14=new JButton("/");
JButton b15=new JButton("首鬧虧.");
JButton b16=new JButton("=");
JButton bclar=new JButton("清零");
text1.setHorizontalAlignment(JTextField.RIGHT);
c.add(text1,"North");
c.add(pan1);
A aa=new A();
Result re=new Result();
Opertion op=new Opertion();
Clar cl=new Clar();
b1.addActionListener(aa);
b2.addActionListener(aa);
b3.addActionListener(aa);
b4.addActionListener(aa);
b5.addActionListener(aa);
b6.addActionListener(aa);
b7.addActionListener(aa);
b8.addActionListener(aa);
b9.addActionListener(aa);
b0.addActionListener(aa);
b11.addActionListener(op);
b12.addActionListener(op);
b13.addActionListener(op);
b14.addActionListener(op);
b16.addActionListener(re);
b15.addActionListener(aa);
bclar.addActionListener(cl);
pan1.add(b1);
pan1.add(b2);
pan1.add(b3);
pan1.add(b11);
pan1.add(b4);
pan1.add(b5);
pan1.add(b6);
pan1.add(b12);
pan1.add(b7);
pan1.add(b8);
pan1.add(b9);
pan1.add(b13);
pan1.add(b0);
pan1.add(b15);
pan1.add(b16);
pan1.add(b14);
pan1.add(bclar);
f.setSize(200,220);
f.setVisible(true);
}
catch(Exception e)
{
System.out.println(e.getMessage());
}

}
class A implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
String a=text1.getText();
String s=e.getActionCommand();
if(a.equals("0.")||a.equals("+")||a.equals("-")||a.equals("*")||a.equals("/"))
text1.setText(s);
else {
if(flag2)
{
text1.setText(s);
flag2=false;
}
else
text1.setText(a+s);

}
}
}
class Opertion implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
cal=e.getActionCommand();
if(flag1==true)
source=text1.getText();
text1.setText(cal);
flag1=false;
flag=true;
}
}
class Result implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
double num1;
num1=Double.parseDouble(source);
object=text1.getText();
double num2;
num2=Double.parseDouble(object);
double result=0;
if(cal.equals("+"))
result=num1+num2;
if(cal.equals("-"))
result=num1-num2;
if(cal.equals("*"))
result=num1*num2;
if(cal.equals("/"))
if(num2==0)
text1.setText("除數不能為0");
else
result=num1/num2;
String s1=Double.toString(result);
text1.setText(s1);
flag1=true;
flag2=true;
}
}
class Clar implements ActionListener
{
public void actionPerformed(ActionEvent e)
{
text1.setText("0.");
}
}

public static void main(String[] args)
{
Counter count=new Counter();
count.init();
}

public void windowClosing(WindowEvent e){
System.exit(1);
}
public void windowOpened(WindowEvent e){}
public void windowIconified(WindowEvent e){}
public void windowDeiconified(WindowEvent e){}
public void windowClosed(WindowEvent e){}
public void windowActivated(WindowEvent e){}
public void windowDeactivated(WindowEvent e){}
}

『陸』 JAVA使用面向對象的思想編寫一個計算器~

import java.util.*;

public class Test {

public static void main(String[] argv){
Scanner sc = new Scanner(System.in);
double jieguo = 0;
System.out.print("請輸入第一個數字:");
double num1 = sc.nextDouble();
System.out.print("\n請輸入第二個遲配數字碼輪指:");
double num2 = sc.nextDouble();
System.out.print("\n請輸入運算符號:");
String fuhao = sc.next();
jisuan js = new jisuan();

if(fuhao.equals("+")){
jieguo = js.jiafa(num1,num2);
System.out.println(jieguo);
}else if(fuhao.equals("-")){
jieguo = js.jiafa(num1, num2);
System.out.println(jieguo);
}else if(fuhao.equals("*")){
jieguo = js.chengfa(num1, num2);
System.out.println(jieguo);
}else if(fuhao.equals("/")){
jieguo = js.chufa(num1, num2);
System.out.println(jieguo);
}else{
System.out.println("您輸入的符號不存在");
}
}
}
class jisuan{
public double jiafa(double num1,double num2){
double jieguo = num1+num2;
return jieguo;
}
public double jianfa(double num1,double num2){
double jieguo = num1+num2;
return jieguo;
}
public double chengfa(double num1,double num2){
double jieguo = num1+num2;
return jieguo;
}
public double chufa(double num1,double num2){
double jieguo = num1+num2;
return jieguo;
}
}
如果桐並你還需要封裝屬性的話.. 請網路Hi我...我會繼續的給你搞定...

『柒』 用C++編寫一個計算器程序。用戶輸入兩個運算數和四則運算符，輸出計算結果。

用C++編寫的」輸入兩個運算數和四則運算符，輸出計算結果」計算器程序代碼具體如下：

#include<stdio.h>

void main()

{
int a,b,d;

char c;

printf("請輸入一種運算符： ");

scanf("%c",&c);

printf("請輸入兩個數： ");

scanf("%d",&a);

scanf("%d",&b);

switch(c)

{

case '+':

d=a+b;break;

case '-':

d=a-b;break;

case '*':

d=a*b;break;

case '/':

d=a/b;break;

default: break;

}

printf("%d",d);

}

(7)用編譯器思想做計算器擴展閱讀：

C++不僅擁有計算機高效運行的實用性特徵，同時還致力於提高大規模程序的編程質量與程序設計語言的問題描述能力。

在C++中，類是支持數據封裝的工具，對象則是數據封裝的實現。C++通過建立用戶定義類支持數據封兄液裝和數據隱藏。

在面向對象的程序設計中，將數據和對該數據進行合法操作的函數封裝在一起作為一個類的定義。對象被說明為具有一個給定類的變數。

每個給定類的對象包含這個類所規定的若干私有成員、公有成員及保護成員。完好定義的類一旦建立，就可看成完頃差全封裝的實體，可以作為一個整體單元使用。類的實際內部工作隱藏起來，使用完好定義的類的用戶不需要知道類是如何工作的，只要知道如何使用它即可。

在C++現有類的基礎上可以聲明新類型，這就是繼承和重用的思想。通過繼承和重用可以更有效地組織程序結構，明確類間關系，並且充雀塵皮分利用已有的類來完成更復雜、深入的開發。新定義的類為子類，成為派生類。它可以從父類那裡繼承所有非私有的屬性和方法，作為自己的成員。

『捌』 C#如何做計算器

就是簡單的用編程代碼把輸入的兩個值用變數保存起來，在進行相加相減相卜缺除相乘...得到的結果在用一個變數保存起來，輸出結果。流程思想就是這樣，沒什麼難度。C# 如果選擇窗體編程會更可視化。都是人家寫好的插件。輸入框直接拖入，加減乘除按鈕直接拖入就能設計出按照自己想法外觀的計算器。雙擊就能寫點邏輯代碼即模弊可。編程最主要的是思想。思想理清了，旦弊族剩下的就是語法了，多練多看多理解多創新。高手都是這么練成的。

『玖』 科學計算器如何用C程序……

#include <iostream.h>
#include <string>
using namespace std;

/**************Simple Calculator Code*************************
This program is abstracted from <C++ Programming Language>
all the ideas belong to original author

you can study from it

how to use ?
input a line of expression which is ended with ";"
Examples:
you put :
3+(5+6)*(-1+8);
the reult :
80
and you can continue ...
***********************************************************/
enum Token_value{
NAME, NUMBER, END,
PLUS = '+'旦困, MINUS = '-',MUL = '*',DIV = '/',
PRINT = ';',ASSIGN = '=',LP = '(',RP = ')'
};

Token_value curr_tok = PRINT;

// fuction list/////////////////////沒氏/////////////////
double expr(bool get);
double term(bool get);
double prim(bool get);
Token_value get_token();
double error(const string &s);

////////////////////////////////////////////////枯遲散//////////
double expr(bool get) //plus and minus
{
double left = term(get);
for(;;)
{
switch(curr_tok){
case PLUS:
left+=term(true);
break;
case MINUS:
left-=term(true);
break;
default:
return left;
}
}
}

double term(bool get) // multiply and divide
{
double left = prim(get);
for(;;)
{
switch(curr_tok){
case MUL:
left*=prim(true);
break;
case DIV:
if(double d = prim(true)){ // no zero!!
left/= d;
break;
}
return error("divide by zero!!\n");
default :
return left;
}
}
}

double number_value;
double string_value;

double prim(bool get)
{
if(get) get_token();

switch(curr_tok){
case NUMBER:
{
double v = number_value;
get_token();
return v;
}
case NAME:
{
double v;
//double &v = table[string_value];
//this table reserved the name mapped with variable
//now we don't use it!
if(get_token()==ASSIGN)
v = expr(true);
return v;
}
case MINUS: // negative
{
return -prim(true);
}
case LP:
{
double e = expr(true);
if(curr_tok!=RP)return error(")expected");
get_token(); // absorb )
return e;
}
default:
return error("primary expected"); // no primary
}
}

Token_value get_token()
{
char ch =0;
cin>>ch;
switch(ch){
case 0:
return curr_tok=END; //return and assignment
case ';':
case '*':
case '/':
case '+':
case '-':
case '(':
case ')':
case '=':
return curr_tok = Token_value(ch);
case '0':case '1':case '2':case '3':case '4':
case '5':case '6':case '7':case '8':case '9':
case '.':
cin.putback(ch);
cin>>number_value;
return curr_tok = NUMBER;
default:
if(isalpha(ch))
{
cin.putback(ch);
cin>>string_value;
return curr_tok = NAME;
}
error("bad token!");
return curr_tok = PRINT;
}
}

int no_of_error;

double error(const string &s)
{
no_of_error++;
cout<<"error:"<<s.data()<<"\n";
return 1;
}

int main()
{
while(cin)
{
get_token();
if(curr_tok==END)break;
if(curr_tok==PRINT) continue;
cout<<expr(false)<<'\n';
}

return no_of_error;
}
不知道為什麼，在VC下的漢字在這里是亂碼，沒辦法，程序里我只能用English
程序的主要思想：
利用自頂向下的分析方法:(編譯原理）
E= E(+|-)T
T =T(*|/)P
P = i|(E)
不用定義太復雜的數據結構，我是從Bjarne Stroustrup那本書上的代碼稍做修改寫的這個，給你一個參考。

『拾』 用C#做一個計算器，我用兩個數組，一個保存運算符，一個保存數字，最後計算出結果。

需要自己寫演算法實現加減乘除？如果這樣，幫不了你。

取巧的方法：
（1）使用運算符作為拆分符，獲取算式的數字及其出現的先後順序，填入一個自定義的數組中；然後把算式字元串轉為單個字元的數組，從而獲取使用到的運算符及其先後順序。最後，把算式字元碼指吵串轉為程序的算遲侍式，從而得到計算結果。
（2）可以查逗塌找一下這個方法：DataTable.Compute，看完後，你就知道第二種方法怎麼做了。