計算器課程設計報告

⑴ c語言課程設計一個簡單計算器

//名字記不太清了，這個叫遞歸下降演算法，但這個演算法肯定是首先在編回譯原理中的，主要答用在
//各種編譯器中。就是現掃描整個表達式字元串，把其中的運算符找出來，判斷它們的優先順序
//然後按從左到右的順序先計算把優先順序低的運算符和它兩邊的數據壓入，這樣循環做過以後
//再從頭取出一個一個計算，表達式的結構類似與二叉樹，遍歷二叉樹後把結果存在連表中供
//計算。

⑵ java 計算器課程設計報告

import java.awt.*;
import java.awt.event.*;

import javax.swing.*;//導包

class MyClass extends JFrame
//創建一個MyClass類繼承JFrame框架的窗口類，
//也就是說JFrame里有的功能MyClass都能實現
{
a1=new JLabel("第一個數");
//創建一個顯示「第一個數」的標簽
JLabel a2=new JLabel("第二個數");
JLabel a3=new JLabel("運算結果");
JTextField b1=new JTextField(5);
//創建一個文本框、默認長度為5，用來輸入運算數字,當然也可以默認為空
JTextField b2=new JTextField(5);
JTextField b3=new JTextField(5);
//創建一個用於顯示運算結果的標簽，也可以創建一個標簽來顯示
JButton a=new JButton("加");
//創建一個用於加法計算的按鈕,點擊時進行加法運算
JButton b=new JButton("減");
JButton c=new JButton("乘");
JButton d=new JButton("除");
JPanel jp1=new JPanel();//創建一個面板，用來放控制項
JPanel jp2=new JPanel();
JPanel jp3=new JPanel();
MyClass()//構造函數，用來初始化的
{
setLayout(new GridLayout(3,1));//添加一個四行四列的布局管理器
jp1.setLayout(new FlowLayout());//設置JP1面板為流式布局管理器
jp1.setLayout(new FlowLayout());
//將a1,b1,a2,b2四個控制項添加到jp1面板中
jp1.add(a1);
jp1.add(b1);
jp1.add(a2);
jp1.add(b2);
jp1.add(a3);
//將a,b,c,d四個控制項添加到jp2面板中
jp2.add(a);
jp2.add(b);
jp2.add(c);
jp2.add(d);
jp3.add(a3);
jp3.add(b3);
//將jp1,jp2,jp3三個面板添加到窗口中
add(jp1);
add(jp3);
add(jp2);
Object e;
a.addActionListener(new ActionListener()
//創建一個匿名的事件監聽器
{

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
double x=Double.valueOf(b1.getText().toString());
//獲取第一個輸入數，並將其由String型轉換成double型
double y=Double.valueOf(b2.getText().toString());
//獲取第二個輸入數，並將其由String型轉換成double型
b3.setText(""+(x+y));
//將運算結果在b3這個文本框中顯示
}

});
b.addActionListener(new ActionListener()
{

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
double x=Double.valueOf(b1.getText().toString());
double y=Double.valueOf(b2.getText().toString());
b3.setText(""+(x-y));
}

});
c.addActionListener(new ActionListener()//創建一個匿名的事件監聽器
{

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
double x=Double.valueOf(b1.getText().toString());
double y=Double.valueOf(b2.getText().toString());
b3.setText(""+(x*y));
}

});
d.addActionListener(new ActionListener()//創建一個匿名的事件監聽器
{

@Override
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
double x=Double.valueOf(b1.getText().toString());
double y=Double.valueOf(b2.getText().toString());
//因為0不能做除數，所以在這里需要進行判斷
if(y==0)
{
b3.setText("錯誤");
}
else
{
b3.setText(""+(x/y));
}
}

});
//下面的是設置窗口的屬性
this.setTitle("計算器");//設置窗口的標題
//this.setSize(400,400);//設置窗口的大小，也可以改成this.pack()
this.pack();
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);//設置關閉屬性
this.setVisible(true);//設置窗口的可見性
}
public static void main(String[] args)//主函數
{
new MyClass();
}
}

⑶ C++計算器課程設計報告摘要 該怎麼寫

摘要主要寫你這個課程設計要實現的功能，就是利用c++語言實現計算器的功能，實現這個功能需要使用的軟體，比如是基於visual c++6.0 MFC開發的，還有功能實現的結果如何，比如實現了多少范圍內的整數、浮點數的加減乘除，求余運算，還有包括開平方等等。

⑷ 急求java計算器 課程設計報告

Java課程設計報告
題 目： 計算器
院（系）：xxx學院
年級專業： xxx班
學生姓名： xxx
指導老師： xx老師
開始時間： 200x-xx-xx
完成時間： 200x-xx-xx
目 錄
1． 摘 要
2． 概要設計
3． 詳細設計
4． 測試分析
5． 參考文獻
一、摘 要
本計算器可以進行簡單的四則運算（加、減、乘、除）但僅限於十進制下，還可以進行（八進制，十進制，十六進制）之間的相互轉換，八進制最多可以輸入19位數，十進制最多可以輸入18位數，十六進制最多可以輸入14位數,backspace表示退格, clear表示初始化，在window下直接運行（Jsp2003.bat）即可，界面為灰白對稱。
二、概要設計
（1） 自定義類說明
**********************************************************
* 類名: This_number_too_big *
* 作用: 自定義的異常類，用來處理計算結果溢出 *
* 繼承的父類: Exception類 *
* 實現的介面: 沒有 *
**********************************************************
class This_number_too_big extends Exception
{
}//自定義的一個結果溢出異常類
**********************************************************
* 類名: Jsp2003 *
* 作用: 主類。 *
* 繼承的父類: Frame類 *
* 實現的介面: ItemListener類,ActionListener類 *
**********************************************************
class Jsp2003 extends Frame implements ItemListener,ActionListener
{
public int number=0,length=18;
//number是用來記錄輸入的數字個數，
//length是用來設置在不同進制下允許輸入的最多數字位數，默認為十進制 public char mark='n';
//設置運算符號為沒有即為『n』，它的值是『+』『-』『*』『/』
public double data=0;
//設置運算數據為零
public char ch;
//用來臨時存放所按按鈕的第一個字元
public boolean Refresh=false;
//設置lab是否要在輸入數據的時候刷新，初始為否
主要方法說明：
------------------------------------------------------------------------------------------------
//用來處理按了運算符後的計算-
public void js() throws This_number_too_big //指定由method拋出異常
{if (mark=='n') //沒有運算符
{mark=ch; //，則設置運算符為剛剛輸入的字元，
data=Double.parseDouble(lab.getText());//則設置運算數據為lab的值
Refresh=true;//則設置下一次輸入的時候要刷新lab
}
else //如果採用的是連續運算（即沒有使用『=』號）則運行下面的語句
{switch (mark) //根據運算符計算結果，並把結果保存到data
{ case '+': data+=Double.parseDouble(lab.getText()); break;
case '-': data-=Double.parseDouble(lab.getText()); break;
case '*': data*=Double.parseDouble(lab.getText()); break;
case '/': data/=Double.parseDouble(lab.getText()); break;}
lab.setText(Double.toString(data)); //顯示運算結果
mark=ch;//設置運算符為剛剛按下的運算符
Refresh=true;//則設置下一次輸入的時候要刷新lab
number=lab.getText().length();//設置輸入的字元個數
// System.out.println(lab.getText());//用來調試用的
if (data>Double.MAX_VALUE)
//如果data超過double類型的最大值則拋出自定義的一個異常類
{throw new This_number_too_big(); }
}
}//end js() method
----------------------------------------------------------------------------------------------------
public void enter()//處理輸入字元
{if(Refresh==true)
//如果已經設置了 運算符則在下一次輸入數據的時候要把以前lab的內容清除掉
{lab.setText("0"); number=0; Refresh=false;}
if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)
//如果lab的內容為0則，lab的內容將被所輸入的字元代替，
//否則直接在lab的內容後面加上所輸入的字元
{lab.setText(Character.toString(ch)); number++;}
else
if(number<length)
{number++;lab.setText(lab.getText()+ch);}
}//end enter() method
--------------------------------------------------------------------------------------------------------
//八進制或十六進制轉換成十進制I
public String goto_10(String s,long l)
//參數s： 是要轉換的字元串，由於輸入的控制，保證了字元串的合法性；
//參數l： 使用來設置是將8進制還是16進制轉換成10進制，它的有效值為8或16；
{ String str=s; //用來轉換的字元串
long j=l; //表示進制
long lg=0,jing=1;//lg用來記錄權乘和，jing用來記錄位權
char cha;//臨時記錄要轉換的字元
for(int i=1;i<=str.length();i++)
{ cha=str.charAt(str.length()-i);
switch(cha)
{ case '1': lg=lg+1*jing;break;
case '2': lg=lg+2*jing;break;
case '3': lg=lg+3*jing;break;
case '4': lg=lg+4*jing;break;
case '5': lg=lg+5*jing;break;
case '6': lg=lg+6*jing;break;
case '7': lg=lg+7*jing;break;
case '8': lg=lg+8*jing;break;
case '9': lg=lg+9*jing;break;
case 'A': lg=lg+10*jing;break;
case 'B': lg=lg+11*jing;break;
case 'C': lg=lg+12*jing;break;
case 'D': lg=lg+13*jing;break;
case 'E': lg=lg+14*jing;break;
case 'F': lg=lg+15*jing;break;}
jing*=j; //位權升一級，為下次使用做好准備
}
return Long.toString(lg);
}//end String goto_10() method
}
（2）程序流程圖

三、詳細設計
import java.awt.*;
import java.awt.event.*;
class This_number_too_big extends Exception
{}//自定義的一個結果溢出異常類
class Jsp2003 extends Frame implements ItemListener,ActionListener {
public Jsp2003() {
addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
dispose();
System.exit(0);
}
});
}
static Jsp2003 mainFrame = new Jsp2003();
static Label lab=new Label("0");
static Panel pnl1=new Panel(new GridLayout(4,3,3,3));
static Panel pnl2=new Panel(new GridLayout(4,1,3,3));
static Panel pnl3=new Panel(new GridLayout(1,2,3,3));
static Panel pnl4=new Panel(new GridLayout(6,1,3,3));
static Button bt9=new Button("9");
static Button bt8=new Button("8");
static Button bt7=new Button("7");
static Button bt6=new Button("6");
static Button bt5=new Button("5");
static Button bt4=new Button("4");
static Button bt3=new Button("3");
static Button bt2=new Button("2");
static Button bt1=new Button("1");
static Button bt0=new Button("0");
static Button btdot=new Button(".");
static Button btequ=new Button("=");
static Button btadd=new Button("+");
static Button btsub=new Button("-");
static Button btmul=new Button("*");
static Button btdev=new Button("/");
static Button btA=new Button("A");
static Button btB=new Button("B");
static Button btC=new Button("C");
static Button btD=new Button("D");
static Button btE=new Button("E");
static Button btF=new Button("F");
static Checkbox ckb8=new Checkbox("八進制");
static Checkbox ckb10=new Checkbox("十進制");
static Checkbox ckb16=new Checkbox("十六進制");
static Button btc=new Button("clear");
static Button btt=new Button("backspace");
public int number=0,length=18;
//number是用來記錄輸入的數字個數，length是用來設置在不同進制下允許輸入的最多數字位數，默認為十進制
public char mark='n'; //設置運算符號為沒有即為『n』，它的值是『+』『-』『*』『/』
public double data=0; //設置運算數據為零
public char ch; //用來臨時存放所按按鈕的第一個字元
public boolean Refresh=false;//設置lab是否要在輸入數據的時候刷新，初始為否
public static void main(String args[]) {
System.out.println("Starting Jsp2003...");
lab.setAlignment(Label.RIGHT);
lab.setBackground(Color.lightGray);
lab.setForeground(Color.BLUE);
lab.setFont(new Font("Serief",Font.BOLD,18));
lab.setBounds(14,33,216,40);
mainFrame.add(lab);
CheckboxGroup grp=new CheckboxGroup();
ckb8.setCheckboxGroup(grp);
ckb10.setCheckboxGroup(grp);
ckb16.setCheckboxGroup(grp);
ckb8.setBounds(14,75,55,25);
ckb10.setBounds(69,75,55,25);
ckb16.setBounds(124,75,65,25);
ckb8.setState(false);
ckb10.setState(true);
ckb16.setState(false);
mainFrame.add(ckb8);
mainFrame.add(ckb10);
mainFrame.add(ckb16);
pnl1.setBounds(14,140,120,150);
pnl2.setBounds(144,140,40,150);
pnl3.setBounds(14,100,170,36);
pnl4.setBounds(190,100,40,190);
pnl1.add(bt7);
pnl1.add(bt8);
pnl1.add(bt9);
pnl1.add(bt4);
pnl1.add(bt5);
pnl1.add(bt6);
pnl1.add(bt1);
pnl1.add(bt2);
pnl1.add(bt3);
pnl1.add(bt0);
pnl1.add(btdot);
pnl1.add(btequ);
pnl2.add(btadd);
pnl2.add(btsub);
pnl2.add(btmul);
pnl2.add(btdev);
pnl3.add(btt);
pnl3.add(btc);
pnl4.add(btA);
pnl4.add(btB);
pnl4.add(btC);
pnl4.add(btD);
pnl4.add(btE);
pnl4.add(btF);
btA.enable(false);
btB.enable(false);
btC.enable(false)；
btD.enable(false);
btE.enable(false);
btF.enable(false);
mainFrame.add(pnl1);
mainFrame.add(pnl2);
mainFrame.add(pnl3);
mainFrame.add(pnl4);
mainFrame.setResizable(false);
mainFrame.setLayout(null);
mainFrame.setSize(240,300 );
mainFrame.setTitle("計算器");
mainFrame.setVisible(true);
ckb8.addItemListener(mainFrame);
ckb10.addItemListener(mainFrame);
ckb16.addItemListener(mainFrame);
//把事件聆聽者向各個組鍵注冊
bt1.addActionListener(mainFrame);
bt2.addActionListener(mainFrame);
bt3.addActionListener(mainFrame);
bt4.addActionListener(mainFrame);
bt5.addActionListener(mainFrame);
bt6.addActionListener(mainFrame);
bt7.addActionListener(mainFrame);
bt8.addActionListener(mainFrame);
bt9.addActionListener(mainFrame);
bt0.addActionListener(mainFrame);
btadd.addActionListener(mainFrame);
btsub.addActionListener(mainFrame);
btmul.addActionListener(mainFrame);
btdev.addActionListener(mainFrame);
btt.addActionListener(mainFrame);
btc.addActionListener(mainFrame);
btdot.addActionListener(mainFrame);
btequ.addActionListener(mainFrame);
btA.addActionListener(mainFrame);
btB.addActionListener(mainFrame);
btC.addActionListener(mainFrame);
btD.addActionListener(mainFrame);
btE.addActionListener(mainFrame);
btF.addActionListener(mainFrame);
}// end main() mothed
//---------------------------------------------
//checkbox 事件的處理
public void itemStateChanged(ItemEvent e)
{ mark='n';
Refresh=false;
//規定當進制轉換時以前輸入的運算符失效
if (ckb8.getState()==true)
{ btA.enable(false);
btB.enable(false);
btC.enable(false);
btD.enable(false);
btE.enable(false);
btF.enable(false);
bt9.enable(false);
bt8.enable(false);
btdot.enable(false);
btadd.enable(false);
btmul.enable(false);
btsub.enable(false);
btdev.enable(false);
btequ.enable(false);
//在八進制的情況下對有些按件的管理
if(length==18) { lab.setText(goto10_8(lab.getText()));
number=lab.getText().length();
}
if(length==14) { lab.setText(goto_10(lab.getText(),16L));
lab.setText(goto10_8(lab.getText()));
number=lab.getText().length();
}
//將其他進制轉換成八進制
length=19;
//在八進制下允許輸入數字個數最多為19位
}
if(ckb10.getState()==true)
{ btA.enable(false);
btB.enable(false);
btC.enable(false);
btD.enable(false);
btE.enable(false);
btF.enable(false);
bt9.enable(true);
bt8.enable(true);
btdot.enable(true);
btadd.enable(true);
btmul.enable(true);
btsub.enable(true);
btdev.enable(true);
btequ.enable(true);
//在十進制的情況下對有些按件的管理
if(length==19) { lab.setText(goto_10(lab.getText(),8L));
number=lab.getText().length();}
if(length==14) { lab.setText(goto_10(lab.getText(),16L));
number=lab.getText().length();}
//進制轉換成十進制
length=18;
//在十進制下允許輸入數字個數最多為18位
}
if(ckb16.getState()==true)
{ btA.enable(true);
btB.enable(true);
btC.enable(true);
btD.enable(true);
btE.enable(true);
btF.enable(true);
bt9.enable(true);
bt8.enable(true);
btdot.enable(false);
btadd.enable(false);
btmul.enable(false);
btsub.enable(false);
btdev.enable(false);
btequ.enable(false);
//在十六進制的情況下對有些按件的管理
if(length==18) { lab.setText(goto10_16(lab.getText()));
number=lab.getText().length();}
if(length==19) { lab.setText(goto_10(lab.getText(),8L));
lab.setText(goto10_16(lab.getText()));
number=lab.getText().length();}
//將其他進制轉換成十六進制
length=14;
//在十六進制下允許輸入數字個數最多為14位
}
}//end itemStateChanged(ItemEvent e) method
//------------------------------------------------------------
//按鈕事件的處理
public void actionPerformed(ActionEvent m)
{
Button btn=(Button) m.getSource();
ch=btn.getLabel().charAt(0);
switch (ch)
{ case 'c': {lab.setText("0"); number=0; mark='n'; Refresh=false;}break;//初始化
case '1': enter(); break;
case '2': enter(); break;
case '3': enter(); break;
case '4': enter(); break;
case '5': enter(); break;
case '6': enter(); break;
case '7': enter(); break;
case '8': enter(); break;
case '9': enter(); break;
case '0': {if(Refresh==true) { lab.setText("0"); number=0; Refresh=false; }
if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)
break;
if(number<length)
{number++;lab.setText(lab.getText()+ch);} else break;
} break;
case 'A': enter(); break;
case 'B': enter(); break;
case 'C': enter(); break;
case 'D': enter(); break;
case 'E': enter(); break;
case 'F': enter(); break;
case '.': {if(Refresh==true) {lab.setText("0"); number=0; Refresh=false;}
if(lab.getText().indexOf('.')== -1)
{number++;lab.setText(lab.getText()+ch);}
else
break;
}
break;
case 'b': {if(number==0) break;
else
{if(--number==0) {lab.setText("0"); number=0;}
else
{if (number!=1) lab.setText(lab.getText().substring(0,number));
else
lab.setText(Character.toString(lab.getText().charAt(0)));}
}
}break;
case '+': try
{ js();}
catch(This_number_too_big e)
{lab.setText("0"); number=0; mark='n';
Refresh=false; System.out.println("The number is too big");} break;
//如果出現異常則初始化效果如同clear鍵
case '-': try
{ js();}
catch(This_number_too_big e)
{lab.setText("0"); number=0; mark='n';
Refresh=false; System.out.println("The number is too big");} break;
//如果出現異常則初始化效果如同clear鍵
case '*': try
{ js();}
catch(This_number_too_big e)
{lab.setText("0"); number=0; mark='n';
Refresh=false; System.out.println("The number is too big");} break;
//如果出現異常則初始化效果如同clear鍵
case '/': try
{ js();}
catch(This_number_too_big e)
{lab.setText("0"); number=0; mark='n';
Refresh=false; System.out.println("The number is too big");} break;
//如果出現異常則初始化效果如同clear鍵
case '=': try
{ js();}
catch(This_number_too_big e)
{lab.setText("0"); number=0; mark='n';
Refresh=false; System.out.println("The number is too big");} break;
//如果出現異常則初始化效果如同clear鍵
}
}//end actionPerformed(ActionEvent e) method
//八進制或十六進制轉換成十進制I
//-------------------------------------Infinity
public String goto_10(String s,long l)
//參數s： 是要轉換的字元串，由於輸入的控制，保證了字元串的合法性；
//參數l： 使用來設置是將8進制還是16進制轉換成10進制，它的有效值為8或16；
{
String str=s; //用來轉換的字元串
long j=l; //表示進制
long lg=0,jing=1;//lg用來記錄權乘和，jing用來記錄位權
char cha;//臨時記錄要轉換的字元
for(int i=1;i<=str.length();i++)
{
cha=str.charAt(str.length()-i);
switch(cha)
{
case '1': lg=lg+1*jing;break;
case '2': lg=lg+2*jing;break;
case '3': lg=lg+3*jing;break;
case '4': lg=lg+4*jing;break;
case '5': lg=lg+5*jing;break;
case '6': lg=lg+6*jing;break;
case '7': lg=lg+7*jing;break;
case '8': lg=lg+8*jing;break;
case '9': lg=lg+9*jing;break;
case 'A': lg=lg+10*jing;break;
case 'B': lg=lg+11*jing;break;
case 'C': lg=lg+12*jing;break;
case 'D': lg=lg+13*jing;break;
case 'E': lg=lg+14*jing;break;
case 'F': lg=lg+15*jing;break;}
jing*=j; //位權升一級，為下次使用做好准備
}
return Long.toString(lg);
}//end String goto_10() method
//十進制轉換成十六進制
//-------------------------------------
public String goto10_16(String s)
//參數s： 是要轉換的字元串，由於輸入的控制，保證了字元串的合法性；
{ String str=s; //用來轉換的字元串
String st=new String();//用來記錄16進制值的字元串
long ch; //每次取余有的值
int k; //將每次取余有的值轉換成整形，用來選擇轉換的16進制字元
long lg;//用來轉換的10進制數
if(str.charAt(0)=='-') //如果有負號則出去負號
str=str.substring(1,str.length()-1);
if(str.indexOf('E')!= -1)//如果是科學計數值則出去小數點和E後面的數
str=str.charAt(0)+str.substring(2,str.indexOf('E'));
if (str.indexOf('.')!= -1)//如果有小數點則出去小數點及小數點後面的內容
str=str.substring(0,str.indexOf('.'));
lg=Long.parseLong(str);//將簡化的字元串轉化為長整形給lg
while (lg>=16)
{ ch=lg%16;
k=(int)ch;
switch (k)
{case 10: st="A"+st;break;
case 11: st="B"+st;break;
case 12: st="C"+st;break;
case 13: st="D"+st;break;
case 14: st="E"+st;break;
case 15: st="F"+st;break;
default: st=Long.toString(ch)+st;
}
lg=lg/16;
}
k=(int)lg;
switch (k)
{case 10: st="A"+st;break;
case 11: st="B"+st;break;
case 12: st="C"+st;break;
case 13: st="D"+st;break;
case 14: st="E"+st;break;
case 15: st="F"+st;break;
default: st=Long.toString(lg)+st;
}
return st;
}//end goto10_16() method
//-----------------------------------------------
//十進制轉換成八進制?
public String goto10_8(String s)
//參數s： 是要轉換的字元串，由於輸入的控制，保證了字元串的合法性；
{ String str=s;
String st=new String();
long j=8,ch;
long lg;
if(str.charAt(0)=='-') //如果有負號則出去負號
str=str.substring(1,str.length()-1);
if(str.indexOf('E')!= -1)//如果是科學計數值則出去小數點和E後面的數
str=str.charAt(0)+str.substring(2,str.indexOf('E'));
if (str.indexOf('.')!= -1)//如果有小數點則出去小數點及小數點後面的內容
str=str.substring(0,str.indexOf('.'));
lg=Long.parseLong(str);
while (lg>=j)
{ ch=lg%j;
st=Long.toString(ch)+st;
lg=lg/j;
}
st=Long.toString(lg)+st;
return st;
}//end goto10_8() method
//--------------------------------
//輸入字元
public void enter()
{if(Refresh==true)
//如果已經設置了 運算符則在下一次輸入數據的時候要把以前lab的內容清除掉
{lab.setText("0"); number=0; Refresh=false;}
if(lab.getText().charAt(0)=='0'&& lab.getText().length()==1)
//如果lab的內容為0則，lab的內容將被所輸入的字元代替，否則直接在lab的內容後面加上所輸入的字元
{lab.setText(Character.toString(ch)); number++;}
else
if(number<length)
{number++;lab.setText(lab.getText()+ch);}
}//end enter() method
//-------------------------------------
//用來處理按了運算符後的計算-
public void js() throws This_number_too_big //指定由method拋出異常
{if (mark=='n') //沒有運算符
{mark=ch; //，則設置運算符為剛剛輸入的字元，
data=Double.parseDouble(lab.getText());//則設置運算數據為lab的值
Refresh=true;//則設置下一次輸入的時候要刷新lab
}
else //如果採用的是連續運算（即沒有使用『=』號）則運行下面的語句
{switch (mark) //根據運算符計算結果，並把結果保存到data
{ case '+': data+=Double.parseDouble(lab.getText()); break;
case '-': data-=Double.parseDouble(lab.getText()); break;
case '*': data*=Double.parseDouble(lab.getText()); break;
case '/': data/=Double.parseDouble(lab.getText()); break;}
lab.setText(Double.toString(data)); //顯示運算結果
mark=ch;//設置運算符為剛剛按下的運算符
Refresh=true;//則設置下一次輸入的時候要刷新lab
number=lab.getText().length();//設置輸入的字元個數
// System.out.println(lab.getText());//用來調試用的
if (data>Double.MAX_VALUE)
//如果data超過double類型的最大值則拋出自定義的一個異常類
{throw new This_number_too_big(); }
}
}//end js() method
//---------------------------
//
public void answer() throws This_number_too_big //指定由method拋出異常
{if (mark=='n')
{}
else
{switch (mark)
{case '+': data+=Double.parseDouble(lab.getText()); break;
case '-': data-=Double.parseDouble(lab.getText()); break;
case '*': data*=Double.parseDouble(lab.getText()); break;
case '/': data/=Double.parseDouble(lab.getText()); break;}
lab.setText(Double.toString(data));
mark='n';}
if (data>Double.MAX_VALUE) //如果data超過double類型的最大值則拋出自定義的一個異常類
{throw new This_number_too_big();}
Refresh=false;
number=lab.getText().length();
}//end answer() method
//---------------------------
}//end class Jsp2003
4． 測試分析
（1）程序運行情況:
程序正常的響應按鈕事件，輸入的數值長度受變數length的限定，進行混合四則運算的時候，結果如果不是很大，可以正常顯示，但如果結果很大，就可能採用科學記數方式，這樣帶來了進制轉換時的麻煩，需要特殊的處理科學記數里的E ，當結果太大的時候，有可能超出可能表示的最大值，（結果溢出），這個時候就要對結果進行必要的異常處理，我在輸出結果的方法內設置if 語句，如果結果大於某一個值就拋出一個This_number_too_big 類型的類，再使用try-catch，捕捉輸出結果的方法拋出的異常對象。然後進行，重製歸零的處理。
（2）程序異常處理:
當結果超出Double.MAX_VALUE時，將拋出一個This_number_too_big 類的異常對象，這個是我自定義的一個異常類它繼承自Exception 類，然後使用try-catch去捕捉這個異常，異常的處理如下：
try
{ js();}
catch(This_number_too_big e)
{
lab.setText("0");
number=0;
mark='n';
Refresh=false;
System.out.println("The number is too big");
} //如果出現異常則初始化效果如同clear鍵
五、參考文獻

⑸ 跪求java課程設計報告！要求：編寫一個類似於windows計算器的程序，能實現加減乘除等基本運算並能處理異常

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.border.TitledBorder;
public class Jisuan extends JFrame implements ActionListener{
private JTextField reasult;
private JButton btn1,btn2,btn3,btn4,btn5,btn6,btn7,btn8,btn9,btn0,
btnAC,btnAdd,btnSub,btnReasult,btnD,
btnAbout,btnCancel;
private boolean add,sub,end,s,c;
private String str;
private double num1,num2;
public Jisuan(){
JPanel p1=new JPanel();
JPanel p2=new JPanel();
JPanel p3=new JPanel();
TitledBorder tb=new TitledBorder("輸出"); tb.setTitleColor(Color.BLUE);

btnAbout=new JButton(" 關於 ");
btnCancel=new JButton("Cancel");
btnCancel.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent ee)
{
System.exit(0);
}
});
btnAbout.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent ee)
{
JOptionPane.showMessageDialog(null,"無",
"消息",JOptionPane.INFORMATION_MESSAGE);
}
});
p3.add(btnAbout);
p3.add(btnCancel);
//JPanel p4=new JPanel();
//JPanel p5=new JPanel();
//reasult.setBorder(tb);
reasult =new JTextField("0",20);
reasult.setEditable(false);
reasult.setHorizontalAlignment(JTextField.RIGHT);
reasult.setForeground(Color.BLUE);

p1.setBorder(tb);
p1.add(reasult);

btn0=new JButton("0"); btn0.addActionListener(this);
btn1=new JButton("1"); btn1.addActionListener(this);
btn2=new JButton("2"); btn2.addActionListener(this);
btn3=new JButton("3"); btn3.addActionListener(this);
btn4=new JButton("4"); btn4.addActionListener(this);
btn5=new JButton("5"); btn5.addActionListener(this);
btn6=new JButton("6"); btn6.addActionListener(this);
btn7=new JButton("7"); btn7.addActionListener(this);
btn8=new JButton("8"); btn8.addActionListener(this);
btn9=new JButton("9"); btn9.addActionListener(this);
btnD=new JButton("."); btnD.addActionListener(this); btnD.setForeground(Color.RED);
btnAC=new JButton("AC"); btnAC.addActionListener(this); btnAC.setBackground(Color.PINK);
btnAdd=new JButton("+"); btnAdd.addActionListener(this); btnAdd.setForeground(Color.BLUE);
btnSub=new JButton("—"); btnSub.addActionListener(this); btnSub.setForeground(Color.BLUE);
btnReasult=new JButton("="); btnReasult.addActionListener(this); btnReasult.setForeground(Color.RED);

p2.add(btn1);p2.add(btn2);p2.add(btn3);p2.add(btn4);p2.add(btn5);
p2.add(btn6);p2.add(btn7);p2.add(btn8);p2.add(btn9);p2.add(btn0);
p2.add(btnD);p2.add(btnAC);p2.add(btnAdd);p2.add(btnSub);p2.add(btnReasult);
p2.setLayout(new GridLayout(5,3));

add(p1,BorderLayout.NORTH);
add(p2,BorderLayout.CENTER);
add(p3,BorderLayout.SOUTH);

}
public void num(int i){
String s = null;
s=String.valueOf(i);
if(end){
//如果數字輸入結束，則將文本框置零，重新輸入
reasult.setText("0");
end=false;

}
if((reasult.getText()).equals("0")){
//如果文本框的內容為零，則覆蓋文本框的內容
reasult.setText(s);
}

else{
//如果文本框的內容不為零，則在內容後面添加數字
str = reasult.getText() + s;
reasult.setText(str);

}
}/*
String s=null;
s=String.valueOf(i);
str=reasult.getText()+s;
reasult.setText(str);
}*/
public void actionPerformed(ActionEvent e){
if(e.getSource()==btn1)
num(1);
else if(e.getSource()==btn2)
num(2);
else if(e.getSource()==btn3)
num(3);
else if(e.getSource()==btn4)
num(4);
else if(e.getSource()==btn5)
num(5);
else if(e.getSource()==btn6)
num(6);
else if(e.getSource()==btn7)
num(7);
else if(e.getSource()==btn8)
num(8);
else if(e.getSource()==btn9)
num(9);
else if(e.getSource()==btn0)
num(0);
else if(e.getSource()==btnAdd){
sign(1);
btnD.setEnabled(true);
}
else if(e.getSource()==btnSub){
sign(2);
btnD.setEnabled(true);
}
else if(e.getSource()==btnAC){
btnD.setEnabled(true);
reasult.setText("0");
}

else if(e.getSource()==btnD){
str=reasult.getText();
str+=".";
reasult.setText(str);
btnD.setEnabled(false);
}
else if(e.getSource()==btnReasult){

btnD.setEnabled(true);
num2=Double.parseDouble(reasult.getText());

if(add){
num1=num1 + num2;}
else if(sub){
num1=num1 - num2;}

reasult.setText(String.valueOf(num1));
end=true;
}

}
public void sign(int s){
if(s==1){
add=true;
sub=false;

}
else if(s==2){
add=false;
sub=true;

}

num1=Double.parseDouble(reasult.getText());
end=true;
}
public static void main(String[] args){
Jisuan j=new Jisuan();
j.setTitle("+/-簡易計算器");
j.setLocation(500,280);
j.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
j.setResizable(false);
j.pack();
j.setVisible(true);
}
}
沒寫乘法，你自其實從網上搜索就能搜出來現成代碼

⑹ 用C++編的分數計算器的課程設計報告,急用!!!!

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX 10
typedef struct
{
char data[MAX];
int top;
}StackChar;
StackChar StackCharInit()
{
StackChar S;
S.top=-1;
return S;
}
void StackCharPush(StackChar &S,char x)
{
if(S.top==MAX-1)
{
printf("Stcak Full!\n");
exit(0);
}
S.top++;
S.data[S.top]=x;
}
char StackCharPop(StackChar &S)
{
if(S.top>=0)
{
char x=S.data[S.top];
S.data[S.top]='\0';
S.top--;
return x;
}
else
{
printf("Stack Empty!\n");
exit(0);
}
}
void StackCharPrint(StackChar S)
{
int i;
for(i=0;i<S.top+1;i++)
printf("%c",S.data[i]);

}
StackChar StackCharClear(StackChar &S)
{
int i;
for(i=S.top;i>=0;i--)
S.data[i]='\0';
S.top=-1;
return S;
}

typedef struct
{
double data[MAX];
int top;
}StackNum;
StackNum StackNumInit()
{
StackNum S;
S.top=-1;
return S;
}
void StackNumPush(StackNum &S,double x)
{
if(S.top==MAX-1)
{
printf("Stcak Full!\n");
exit(0);
}
S.top++;
S.data[S.top]=x;
}
double StackNumPop(StackNum &S)
{
if(S.top>=0)
{
double x=S.data[S.top];
S.data[S.top]=0;
S.top--;
return x;
}
else
{
printf("Stack Empty!\n");
exit(0);
}
}
void StackNumPrint(StackNum S)
{
// int i;
printf("%.10lg",S.data[S.top]);
}
StackNum StackNumClear(StackNum &S)
{
int i;
for(i=S.top;i>=0;i--)
S.data[i]='\0';
S.top=-1;
return S;
}

int op(char c)
{
int b;
switch(c)
{
case '/':
case '*':b=2;break;
case '+':
case '-':b=1;break;
case '(':
case ')':b=0;break;
case '=':b=-1;break;
}
return b;
}
double compute(double a,double b,char op)
{
double c;
switch(op)
{
case '/':c=a/b;break;
case '*':c=a*b;break;
case '+':c=a+b;break;
case '-':c=a-b;break;
}
return c;
}
int main()
{
StackChar s1=StackCharInit();
StackChar op1=StackCharInit();
StackNum num=StackNumInit();
StackCharPush(op1,'=');
char c,min;
int open=0;
while(scanf("%c",&c),c!='#')
{
if(c=='\n')
{
// StackNumPrint(num);
// printf("\n");
StackNumClear(num);
continue;
}
if((c<='9'&&c>='0'||c=='.')||open==1&&c=='-')
{
StackCharPush(s1,c);
open=0;
}
else
{
if(c!='('&&open==0)
{
StackNumPush(num,atof(s1.data));
StackCharClear(s1);
}
open=1;
if(op(c)==-1)
{
while(op(op1.data[op1.top])!=-1)
{
StackNumPush(num,compute(StackNumPop(num),StackNumPop(num),StackCharPop(op1)));
}
open=0;
}
else if(c==')')
{
while(op(op1.data[op1.top])!=0)
StackNumPush(num,compute(StackNumPop(num),StackNumPop(num),StackCharPop(op1)));
min=StackCharPop(op1);
open=2;

}
else if(op(c)<=op(op1.data[op1.top])&&op(c)!=0)
{
while(op(c)<=op(op1.data[op1.top]))
StackNumPush(num,compute(StackNumPop(num),StackNumPop(num),StackCharPop(op1)));
StackCharPush(op1,c);
}
else
{
StackCharPush(op1,c);
}
StackNumPrint(num);
printf("\n");
/*
if(op(c)==-1)
{
while(op(op1.data[op1.top])!=-1)
StackCharPush(s1,StackCharPop(op1));
}
else if(c==')')
{
StackCharPush(s1,' ');
while(op(op1.data[op1.top])!=0)
StackCharPush(s1,StackCharPop(op1));
min=StackCharPop(op1);
open=0;
}
else if(op(c)<=op(op1.data[op1.top])&&op(c)!=0)
{
StackCharPush(s1,' ');
while(op(c)<=op(op1.data[op1.top]))
StackCharPush(s1,StackCharPop(op1));
StackCharPush(op1,c);
}
else
{
if(c=='('&&s1.top!=-1)
StackCharPush(s1,' ');
StackCharPush(op1,c);
}*/
}
}
return 0;
}

⑺ 我要單片機課程設計報告，關於做計算器的

報告已發送到郵箱中，請注意查收，有其他需要再聯系

⑻ 求c語言課程設計【一元多項式簡單的計算器】

#include <dos.h> /*DOS介面函數*/
#include <math.h> /*數學函數的定義*/
#include <conio.h> /*屏幕操作函數*/
#include <stdio.h> /*I/O函數*/
#include <stdlib.h> /*庫函數*/
#include <stdarg.h> /*變數長度參數表*/
#include <graphics.h> /*圖形函數*/
#include <string.h> /*字元串函數*/
#include <ctype.h> /*字元操作函數*/
#define UP 0x48 /*游標上移鍵*/
#define DOWN 0x50 /*游標下移鍵*/
#define LEFT 0x4b /*游標左移鍵*/
#define RIGHT 0x4d /*游標右移鍵*/
#define ENTER 0x0d /*回車鍵*/
void *rar; /*全局變數，保存游標圖象*/
struct palettetype palette; /*使用調色板信息*/
int GraphDriver; /* 圖形設備驅動*/
int GraphMode; /* 圖形模式值*/
int ErrorCode; /* 錯誤代碼*/
int MaxColors; /* 可用顏色的最大數值*/
int MaxX, MaxY; /* 屏幕的最大解析度*/
double AspectRatio; /* 屏幕的像素比*/
void drawboder(void); /*畫邊框函數*/
void initialize(void); /*初始化函數*/
void computer(void); /*計算器計算函數*/
void changetextstyle(int font, int direction, int charsize); /*改變文本樣式函數*/
void mwindow(char *header); /*窗口函數*/
int specialkey(void) ; /*獲取特殊鍵函數*/
int arrow(); /*設置箭頭游標函數*/
/*主函數*/
int main()
{
initialize();/* 設置系統進入圖形模式 */
computer(); /*運行計算器 */
closegraph();/*系統關閉圖形模式返迴文本模式*/
return(0); /*結束程序*/
}
/* 設置系統進入圖形模式 */
void initialize(void)
{
int xasp, yasp; /* 用於讀x和y方向縱橫比*/
GraphDriver = DETECT; /* 自動檢測顯示器*/
initgraph( &GraphDriver, &GraphMode, "" );
/*初始化圖形系統*/
ErrorCode = graphresult(); /*讀初始化結果*/
if( ErrorCode != grOk ) /*如果初始化時出現錯誤*/
{
printf("Graphics System Error: %s\n",
grapherrormsg( ErrorCode ) ); /*顯示錯誤代碼*/
exit( 1 ); /*退出*/
}
getpalette( &palette ); /* 讀面板信息*/
MaxColors = getmaxcolor() + 1; /* 讀取顏色的最大值*/
MaxX = getmaxx(); /* 讀屏幕尺寸 */
MaxY = getmaxy(); /* 讀屏幕尺寸 */
getaspectratio( &xasp, &yasp ); /* 拷貝縱橫比到變數中*/
AspectRatio = (double)xasp/(double)yasp;/* 計算縱橫比值*/
}
/*計算器函數*/
void computer(void)
{
struct viewporttype vp; /*定義視口類型變數*/
int color, height, width;
int x, y,x0,y0, i, j,v,m,n,act,flag=1;
float num1=0,num2=0,result; /*操作數和計算結果變數*/
char cnum[5],str2[20]={""},c,temp[20]={""};
char str1[]="1230.456+-789*/Qc=^%";/* 定義字元串在按鈕圖形上顯示的符號 */
mwindow( "Calculator" ); /* 顯示主窗口 */
color = 7; /*設置灰顏色值*/
getviewsettings( &vp ); /* 讀取當前窗口的大小*/
width=(vp.right+1)/10; /* 設置按鈕寬度 */
height=(vp.bottom-10)/10 ; /*設置按鈕高度 */
x = width /2; /*設置x的坐標值*/
y = height/2; /*設置y的坐標值*/
setfillstyle(SOLID_FILL, color+3);
bar( x+width*2, y, x+7*width, y+height );
/*畫一個二維矩形條顯示運算數和結果*/
setcolor( color+3 ); /*設置淡綠顏色邊框線*/
rectangle( x+width*2, y, x+7*width, y+height );
/*畫一個矩形邊框線*/
setcolor(RED); /*設置顏色為紅色*/
outtextxy(x+3*width,y+height/2,"0."); /*輸出字元串"0."*/
x =2*width-width/2; /*設置x的坐標值*/
y =2*height+height/2; /*設置y的坐標值*/
for( j=0 ; j<4 ; ++j ) /*畫按鈕*/
{
for( i=0 ; i<5 ; ++i )
{
setfillstyle(SOLID_FILL, color);
setcolor(RED);
bar( x, y, x+width, y+height ); /*畫一個矩形條*/
rectangle( x, y, x+width, y+height );
sprintf(str2,"%c",str1[j*5+i]);
/*將字元保存到str2中*/
outtextxy( x+(width/2), y+height/2, str2);
x =x+width+ (width / 2) ; /*移動列坐標*/
}
y +=(height/2)*3; /* 移動行坐標*/
x =2*width-width/2; /*復位列坐標*/
}
x0=2*width;
y0=3*height;
x=x0;
y=y0;
gotoxy(x,y); /*移動游標到x,y位置*/
arrow(); /*顯示游標*/
putimage(x,y,rar,XOR_PUT);
m=0;
n=0;
strcpy(str2,""); /*設置str2為空串*/
while((v=specialkey())!=45) /*當壓下Alt+x鍵結束程序，否則執行下面的循環*/
{
while((v=specialkey())!=ENTER) /*當壓下鍵不是回車時*/
{
putimage(x,y,rar,XOR_PUT); /*顯示游標圖象*/
if(v==RIGHT) /*右移箭頭時新位置計算*/
if(x>=x0+6*width)
/*如果右移，移到尾，則移動到最左邊字元位置*/
{
x=x0;
m=0;
}
else
{
x=x+width+width/2;
m++;
} /*否則，右移到下一個字元位置*/
if(v==LEFT) /*左移箭頭時新位置計算*/
if(x<=x0)
{
x=x0+6*width;
m=4;
} /*如果移到頭，再左移，則移動到最右邊字元位置*/
else
{
x=x-width-width/2;
m--;
} /*否則，左移到前一個字元位置*/
if(v==UP) /*上移箭頭時新位置計算*/
if(y<=y0)
{
y=y0+4*height+height/2;
n=3;
} /*如果移到頭，再上移，則移動到最下邊字元位置*/
else
{
y=y-height-height/2;
n--;
} /*否則，移到上邊一個字元位置*/
if(v==DOWN) /*下移箭頭時新位置計算*/
if(y>=7*height)
{
y=y0;
n=0;
} /*如果移到尾，再下移，則移動到最上邊字元位置*/
else
{
y=y+height+height/2;
n++;
} /*否則，移到下邊一個字元位置*/
putimage(x,y,rar,XOR_PUT); /*在新的位置顯示游標箭頭*/
}
c=str1[n*5+m]; /*將字元保存到變數c中*/
if(isdigit(c)||c=='.') /*判斷是否是數字或小數點*/
{
if(flag==-1) /*如果標志為-1，表明為負數*/
{
strcpy(str2,"-"); /*將負號連接到字元串中*/
flag=1;
} /*將標志值恢復為1*/
sprintf(temp,"%c",c); /*將字元保存到字元串變數temp中*/
strcat(str2,temp); /*將temp中的字元串連接到str2中*/
setfillstyle(SOLID_FILL,color+3);
bar(2*width+width/2,height/2,15*width/2,3*height/2);
outtextxy(5*width,height,str2); /*顯示字元串*/
}
if(c=='+')
{
num1=atof(str2); /*將第一個操作數轉換為浮點數*/
strcpy(str2,""); /*將str2清空*/
act=1; /*做計算加法標志值*/
setfillstyle(SOLID_FILL,color+3);
bar(2*width+width/2,height/2,15*width/2,3*height/2);
outtextxy(5*width,height,"0."); /*顯示字元串*/
}
if(c=='-')
{
if(strcmp(str2,"")==0) /*如果str2為空，說明是負號，而不是減號*/
flag=-1; /*設置負數標志*/
else
{
num1=atof(str2); /*將第二個操作數轉換為浮點數*/
strcpy(str2,""); /*將str2清空*/
act=2; /*做計算減法標志值*/
setfillstyle(SOLID_FILL,color+3);
bar(2*width+width/2,height/2,15*width/2,3*height/2); /*畫矩形*/
outtextxy(5*width,height,"0."); /*顯示字元串*/
}
}
if(c=='*')
{
num1=atof(str2); /*將第二個操作數轉換為浮點數*/
strcpy(str2,""); /*將str2清空*/
act=3; /*做計算乘法標志值*/
setfillstyle(SOLID_FILL,color+3); bar(2*width+width/2,height/2,15*width/2,3*height/2);
outtextxy(5*width,height,"0."); /*顯示字元串*/
}
if(c=='/')
{
num1=atof(str2); /*將第二個操作數轉換為浮點數*/
strcpy(str2,""); /*將str2清空*/
act=4; /*做計算除法標志值*/
setfillstyle(SOLID_FILL,color+3);
bar(2*width+width/2,height/2,15*width/2,3*height/2);
outtextxy(5*width,height,"0."); /*顯示字元串*/
}
if(c=='^')
{
num1=atof(str2); /*將第二個操作數轉換為浮點數*/
strcpy(str2,""); /*將str2清空*/
act=5; /*做計算乘方標志值*/
setfillstyle(SOLID_FILL,color+3); /*設置用淡綠色實體填充*/
bar(2*width+width/2,height/2,15*width/2,3*height/2); /*畫矩形*/
outtextxy(5*width,height,"0."); /*顯示字元串*/
}
if(c=='%')
{
num1=atof(str2); /*將第二個操作數轉換為浮點數*/
strcpy(str2,""); /*將str2清空*/
act=6; /*做計算模運算乘方標志值*/
setfillstyle(SOLID_FILL,color+3); /*設置用淡綠色實體填充*/
bar(2*width+width/2,height/2,15*width/2,3*height/2); /*畫矩形*/
outtextxy(5*width,height,"0."); /*顯示字元串*/
}
if(c=='=')
{
num2=atof(str2); /*將第二個操作數轉換為浮點數*/
switch(act) /*根據運算符號計算*/
{
case 1:result=num1+num2;break; /*做加法*/
case 2:result=num1-num2;break; /*做減法*/
case 3:result=num1*num2;break; /*做乘法*/
case 4:result=num1/num2;break; /*做除法*/
case 5:result=pow(num1,num2);break; /*做x的y次方*/
case 6:result=fmod(num1,num2);break; /*做模運算*/
}
setfillstyle(SOLID_FILL,color+3); /*設置用淡綠色實體填充*/
bar(2*width+width/2,height/2,15*width/2,3*height/2); /*覆蓋結果區*/
sprintf(temp,"%f",result); /*將結果保存到temp中*/
outtextxy(5*width,height,temp); /*顯示結果*/
}
if(c=='c')
{
num1=0; /*將兩個操作數復位0，符號標志為1*/
num2=0;
flag=1;
strcpy(str2,""); /*將str2清空*/
setfillstyle(SOLID_FILL,color+3); /*設置用淡綠色實體填充*/
bar(2*width+width/2,height/2,15*width/2,3*height/2); /*覆蓋結果區*/
outtextxy(5*width,height,"0."); /*顯示字元串*/
}
if(c=='Q')exit(0); /*如果選擇了q回車，結束計算程序*/
}
putimage(x,y,rar,XOR_PUT); /*在退出之前消去游標箭頭*/
return; /*返回*/
}
/*窗口函數*/
void mwindow( char *header )
{
int height;
cleardevice(); /* 清除圖形屏幕 */
setcolor( MaxColors - 1 ); /* 設置當前顏色為白色*/
setviewport( 20, 20, MaxX/2, MaxY/2, 1 ); /* 設置視口大小 */
height = textheight( "H" ); /* 讀取基本文本大小 */
settextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );/*設置文本樣式*/
settextjustify( CENTER_TEXT, TOP_TEXT );/*設置字元排列方式*/
outtextxy( MaxX/4, 2, header ); /*輸出標題*/
setviewport( 20,20+height+4, MaxX/2+4, MaxY/2+20, 1 ); /*設置視口大小*/
drawboder(); /*畫邊框*/
}
void drawboder(void) /*畫邊框*/
{
struct viewporttype vp; /*定義視口類型變數*/
setcolor( MaxColors - 1 ); /*設置當前顏色為白色 */
setlinestyle( SOLID_LINE, 0, NORM_WIDTH );/*設置畫線方式*/
getviewsettings( &vp );/*將當前視口信息裝入vp所指的結構中*/
rectangle( 0, 0, vp.right-vp.left, vp.bottom-vp.top ); /*畫矩形邊框*/
}
/*設計滑鼠圖形函數*/
int arrow()
{
int size;
int raw[]={4,4,4,8,6,8,14,16,16,16,8,6,8,4,4,4}; /*定義多邊形坐標*/
setfillstyle(SOLID_FILL,2); /*設置填充模式*/
fillpoly(8,raw); /*畫出一游標箭頭*/
size=imagesize(4,4,16,16); /*測試圖象大小*/
rar=malloc(size); /*分配內存區域*/
getimage(4,4,16,16,rar); /*存放游標箭頭圖象*/
putimage(4,4,rar,XOR_PUT); /*消去游標箭頭圖象*/
return 0;
}
/*按鍵函數*/
int specialkey(void)
{
int key;
while(bioskey(1)==0); /*等待鍵盤輸入*/
key=bioskey(0); /*鍵盤輸入*/
key=key&0xff? key&0xff:key>>8; /*只取特殊鍵的掃描值，其餘為0*/
return(key); /*返回鍵值*/
}