理财计算器源代码（理财算法计算器）

本篇文章给大家谈谈理财计算器源代码，以及理财算法计算器对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、vc计算器代码
• 2、java计算器的源代码
• 3、关于ubuntu计算器程序的源代码问题

vc计算器代码

/*

说明:

采用树形结构处理表达式,按优先级运算结果,一个加,减,乘,除或数值为一个节点

优先级如下:

函数:4

括号:3

乘除:2

加减:1

*/

#include windows.h

#include iostream

#include fstream

#include string

#include cmath

using namespace std;

const char NUM[]={'0','1','2','3','4','5','6','7','8','9','.'};

const char OPERATION[]={'+','-','*','/'};

const double PI=3.14159265358979;

const double EE=2.71828182818281;

class Fun //处理系统数学函数的类

{

public:

Fun(string o,int t,double l=0.0,double r=0.0):op(o),type(t),lvalue(l),rvalue(r){}

static string FUN[];

double calc();

private:

int type; //666 0 1 sin90 2 3! 3 3C2

string op; //函数类型

double lvalue; //函数左边的值

double rvalue; //函数右边的值

static int FunNum;

};

int Fun::FunNum=10;

string Fun::FUN[]={"!","sin","cos","tan","log","ln","C","A","^","-"};

/*

函数说明:

1:log是以10为底的工程对数

2:ln 是以e为底的自然对数

3:C 计算组合数 输入规则 如计算 3取2的组合 输入表达式 3C2

4:A 计算排列数 输入规则 如计算 3取2的排列 输入表达式 3A2

5:! 计算阶乘

6:^ x的y次方 输入 x^y

*/

int factorial(int n) //阶乘函数

{

int i,s=1;

for(i=1;i=n;i++)

s*=i;

return s;

}

int C(int a,int b)

{

return factorial(a)/(factorial(b)*factorial(a-b));

}

int A(int a,int b)

{

return factorial(a)/factorial(b);

}

double Fun::calc() //计算系统函数的值

{

if(type==0)

return lvalue;

else

{

if(op=="!")

return factorial(lvalue);

if(op=="sin")

return sin(rvalue/180*PI);

if(op=="cos")

return cos(rvalue/180*PI);

if(op=="tan")

return tan(rvalue/180*PI);

if(op=="log")

return log10(rvalue);

if(op=="ln")

return log10(rvalue)/log10(EE);

if(op=="C")

return C(lvalue,rvalue);

if(op=="A")

return A(lvalue,rvalue);

if(op=="^")

return pow(lvalue,rvalue);

if(op=="-")

return -rvalue;

else

{

string err="暂时没有函数"+op;

MessageBox(NULL,err.c_str(),"错误",MB_OK);

return 0;

}

}

}

struct Unit //双向链表保存运算单元

{

Unit(int p,char o,string c,double v,int t,Unit * pr=NULL,Unit * n=NULL)

:PRI(p),Operation(o),Code(c),value(v),Type(t),Pre(pr),Next(n){}

int PRI; //优先级

char Operation; //操作符

string Code; //原始代码

double value; //数据

int Type; //类型 操作符0 数据1 函数2

Unit * Pre; //构成双向链表

Unit * Next;

};

class Node //表达式树状结构的节点

{

public:

Node(char o,int p,int e=1,double v=0,Node * ph=NULL,Node * pl=NULL,Node * pr=NULL)

:Operation(o),PRI(p),Expression(e),value(v),Head(ph),Left(pl),Right(pr){}

Node * Head; //节点的根,左树枝,右树枝

Node * Left;

Node * Right;

double GetValue();

char GetOperation() const {return Operation;}

int GetPri() const {return PRI;}

int IsExp() const {return Expression;}

private:

char Operation; //操作符

int PRI; //优先级

int Expression; //记录该节点是否是表达式0 1

double value; //该节点的值

};

double Node::GetValue() //运算该节点的值

{

if(IsExp()) //该节点的值还未算出来

{

double lvalue,rvalue;

lvalue=Left-GetValue();

rvalue=Right-GetValue();

Expression=0;

char op=GetOperation();

switch(op)

{

case '+':

return lvalue+rvalue;

case '-':

return lvalue-rvalue;

case '*':

return lvalue*rvalue;

case '/':

return lvalue/rvalue;

default:

return 0;

}

}

else

return value;

}

bool Isnum(char c)

{

for(int i=0;isizeof(NUM);i++)

{

if(c==NUM[i])

return true;

}

return false;

}

bool Isoperation(char c)

{

for(int i=0;isizeof(OPERATION);i++)

{

if(c==OPERATION[i])

return true;

}

return false;

}

Unit * Analyse(string exp) //分析表达式并生成链表

{

int pri=0; //当前优先级

int stat=1; //当前的读入状态 括号 0 运算符 1 其他 2

Unit * head=NULL,* p=NULL;

int i=0,explen;

explen=exp.size();

for(i=0;iexplen;i++)

{

char c=exp.at(i);

if(c=='(')

{

pri+=3;

stat=0;

}

else if(c==')')

{

pri-=3;

stat=0;

}

else if(Isoperation(c) stat!=1) //操作符后的当正负号处理

{

stat=1;

Unit * temp=p;

int add_pri; //自身增加的优先级

if(c=='+' || c=='-')

add_pri=1;

else

add_pri=2;

p-Next=new Unit(pri+add_pri,c," ",0,0);

p=p-Next;

p-Pre=temp;

}

else //其他的当做函数处理

{

stat=2;

string function="";

while(iexplen (c=exp.at(i),! Isoperation(c)) c!=')')

{

function+=c;

i++;

}

i--;

if(head==NULL)

{

p=new Unit(pri,' ',function,0,2);

head=p;

}

else

{

Unit * temp=p;

p-Next=new Unit(pri,' ',function,0,2);

p=p-Next;

p-Pre=temp;

}

}

}

return head;

}

Unit * Calc(Unit * head) //计算双向链表基本单元的值

{

Unit * p=head;

while(p!=NULL)

{

if(p-Type!=0) //非操作符

{

string temp=p-Code;

string op;

double lvalue=0,rvalue=0;

int l_point=0,r_point=0;

int i=0,type=0;

char ch;

while(itemp.size() (ch=temp.at(i),Isnum(ch)))

{

if(ch=='.')

{

l_point++;

i++;

continue;

}

if(! l_point)

lvalue*=10;

lvalue+=(ch-'0')*pow(10,-l_point);

i++;

if(l_point)

l_point++;

}

while(itemp.size() (ch=temp.at(i),! Isnum(ch)))

{

op+=ch;

type=1;

i++;

}

while(itemp.size() (ch=temp.at(i),Isnum(ch)))

{

if(ch=='.')

{

r_point++;

i++;

continue;

}

if(! r_point)

rvalue*=10;

rvalue+=(ch-'0')*pow(10,-r_point);

i++;

if(r_point)

r_point++;

}

Fun * f=new Fun(op,type,lvalue,rvalue);

p-value=f-calc();

}

p=p-Next;

}

return head;

}

Node * Tree(Unit * head) //生成表达式树

{

Node * root=NULL,* proot=NULL,* pbranch=NULL;

Unit * p=head;

int now_pri; //当前优先级

bool hadop=false;

while(p!=NULL)

{

if(p-Type==0) //如果是一个操作符

{

hadop=true;

if(root==NULL)

{

proot=new Node(p-Operation,p-PRI,1);

root=proot;

pbranch=root;

now_pri=p-PRI;

proot-Left=new Node(' ',0,0,p-Pre-value);

proot-Right=new Node(' ',0,0,p-Next-value);

}

else

{

if(p-PRInow_pri) //优先级低于当前优先级,树根方向

{

proot=new Node(p-Operation,p-PRI,1); //新的树根

proot-Left=root; //根的变换

proot-Left-Head=proot;

proot-Right=new Node(' ',0,0,p-Next-value);

proot-Right-Head=proot;

root=proot;

pbranch=proot; //右树枝的变换

//pbranch-Right=new Node(' ',0,0,p-Pre-value); //树枝右边取值

}

else if(p-PRI==now_pri) //优先级相同,先算左边的

{

Node * temp;

temp=new Node(p-Operation,p-PRI,1);

temp-Left=pbranch;

if(pbranch-Head==NULL)

{

proot=temp;

root=proot;

pbranch-Head=proot;

}

else

{

Node * temp0;

temp0=pbranch-Head;

temp0-Right=temp;

temp-Head=temp0;

pbranch-Head=temp;

}

pbranch=temp;

pbranch-Right=new Node(' ',0,0,p-Next-value);

pbranch-Right-Head=pbranch;

}

else

{

Node * temp;

temp=new Node(p-Operation,p-PRI,1);

pbranch-Right=temp;

temp-Head=pbranch;

pbranch=pbranch-Right;

pbranch-Left=new Node(' ',0,0,p-Pre-value);

pbranch-Left-Head=pbranch;

pbranch-Right=new Node(' ',0,0,p-Next-value);

pbranch-Right-Head=pbranch;

}

now_pri=p-PRI;

}

}

p=p-Next;

}

if(! hadop)

root=new Node(' ',0,0,head-value);

return root;

}

int main()

{

string exp;

ifstream infile("test.txt",ios::in);

while(! getline(infile,exp).eof())

{

if(exp=="")

continue;

Unit * h=Analyse(exp);

h=Calc(h);

Node * root=Tree(h);

coutexp"="root-GetValue()endl;

}

return 0;

}

java计算器的源代码

import java.awt.*;

import java.awt.event.*;

import java.lang.*;

import javax.swing.*;

public class Counter extends Frame

{

//声明三个面板的布局

GridLayout gl1,gl2,gl3;

Panel p0,p1,p2,p3;

JTextField tf1;

TextField tf2;

Button b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,b10,b11,b12,b13,b14,b15,b16,b17,b18,b19,b20,b21,b22,b23,b24,b25,b26;

StringBuffer str;//显示屏所显示的字符串

double x,y;//x和y都是运算数

int z;//Z表示单击了那一个运算符.0表示"+",1表示"-",2表示"*",3表示"/"

static double m;//记忆的数字

public Counter()

{

gl1=new GridLayout(1,4,10,0);//实例化三个面板的布局

gl2=new GridLayout(4,1,0,15);

gl3=new GridLayout(4,5,10,15);

tf1=new JTextField(27);//显示屏

tf1.setHorizontalAlignment(JTextField.RIGHT);

tf1.setEnabled(false);

tf1.setText("0");

tf2=new TextField(10);//显示记忆的索引值

tf2.setEditable(false);

//实例化所有按钮、设置其前景色并注册监听器

b0=new Button("Backspace");

b0.setForeground(Color.red);

b0.addActionListener(new Bt());

b1=new Button("CE");

b1.setForeground(Color.red);

b1.addActionListener(new Bt());

b2=new Button("C");

b2.setForeground(Color.red);

b2.addActionListener(new Bt());

b3=new Button("MC");

b3.setForeground(Color.red);

b3.addActionListener(new Bt());

b4=new Button("MR");

b4.setForeground(Color.red);

b4.addActionListener(new Bt());

b5=new Button("MS");

b5.setForeground(Color.red);

b5.addActionListener(new Bt());

b6=new Button("M+");

b6.setForeground(Color.red);

b6.addActionListener(new Bt());

b7=new Button("7");

b7.setForeground(Color.blue);

b7.addActionListener(new Bt());

b8=new Button("8");

b8.setForeground(Color.blue);

b8.addActionListener(new Bt());

b9=new Button("9");

b9.setForeground(Color.blue);

b9.addActionListener(new Bt());

b10=new Button("/");

b10.setForeground(Color.red);

b10.addActionListener(new Bt());

b11=new Button("sqrt");

b11.setForeground(Color.blue);

b11.addActionListener(new Bt());

b12=new Button("4");

b12.setForeground(Color.blue);

b12.addActionListener(new Bt());

b13=new Button("5");

b13.setForeground(Color.blue);

b13.addActionListener(new Bt());

b14=new Button("6");

b14.setForeground(Color.blue);

b14.addActionListener(new Bt());

b15=new Button("*");

b15.setForeground(Color.red);

b15.addActionListener(new Bt());

b16=new Button("%");

b16.setForeground(Color.blue);

b16.addActionListener(new Bt());

b17=new Button("1");

b17.setForeground(Color.blue);

b17.addActionListener(new Bt());

b18=new Button("2");

b18.setForeground(Color.blue);

b18.addActionListener(new Bt());

b19=new Button("3");

b19.setForeground(Color.blue);

b19.addActionListener(new Bt());

b20=new Button("-");

b20.setForeground(Color.red);

b20.addActionListener(new Bt());

b21=new Button("1/X");

b21.setForeground(Color.blue);

b21.addActionListener(new Bt());

b22=new Button("0");

b22.setForeground(Color.blue);

b22.addActionListener(new Bt());

b23=new Button("+/-");

b23.setForeground(Color.blue);

b23.addActionListener(new Bt());

b24=new Button(".");

b24.setForeground(Color.blue);

b24.addActionListener(new Bt());

b25=new Button("+");

b25.setForeground(Color.red);

b25.addActionListener(new Bt());

b26=new Button("=");

b26.setForeground(Color.red);

b26.addActionListener(new Bt());

//实例化四个面板

p0=new Panel();

p1=new Panel();

p2=new Panel();

p3=new Panel();

//创建一个空字符串缓冲区

str=new StringBuffer();

//添加面板p0中的组件和设置其在框架中的位置和大小

p0.add(tf1);

p0.setBounds(10,25,300,40);

//添加面板p1中的组件和设置其在框架中的位置和大小

p1.setLayout(gl1);

p1.add(tf2);

p1.add(b0);

p1.add(b1);

p1.add(b2);

p1.setBounds(10,65,300,25);

//添加面板p2中的组件并设置其的框架中的位置和大小

p2.setLayout(gl2);

p2.add(b3);

p2.add(b4);

p2.add(b5);

p2.add(b6);

p2.setBounds(10,110,40,150);

//添加面板p3中的组件并设置其在框架中的位置和大小

p3.setLayout(gl3);//设置p3的布局

p3.add(b7);

p3.add(b8);

p3.add(b9);

p3.add(b10);

p3.add(b11);

p3.add(b12);

p3.add(b13);

p3.add(b14);

p3.add(b15);

p3.add(b16);

p3.add(b17);

p3.add(b18);

p3.add(b19);

p3.add(b20);

p3.add(b21);

p3.add(b22);

p3.add(b23);

p3.add(b24);

p3.add(b25);

p3.add(b26);

p3.setBounds(60,110,250,150);

//设置框架中的布局为空布局并添加4个面板

setLayout(null);

add(p0);

add(p1);

add(p2);

add(p3);

setResizable(false);//禁止调整框架的大小

//匿名类关闭窗口

addWindowListener(new WindowAdapter(){

public void windowClosing(WindowEvent e1)

{

System.exit(0);

}

});

setBackground(Color.lightGray);

setBounds(100,100,320,280);

setVisible(true);

}

//构造监听器

class Bt implements ActionListener

{

public void actionPerformed(ActionEvent e2)

{

try{

if(e2.getSource()==b1)//选择"CE"清零

{

tf1.setText("0");//把显示屏清零

str.setLength(0);//清空字符串缓冲区以准备接收新的输入运算数

}

else if(e2.getSource()==b2)//选择"C"清零

{

tf1.setText("0");//把显示屏清零

str.setLength(0);

}

else if(e2.getSource()==b23)//单击"+/-"选择输入的运算数是正数还是负数

{

x=Double.parseDouble(tf1.getText().trim());

tf1.setText(""+(-x));

}

else if(e2.getSource()==b25)//单击加号按钮获得x的值和z的值并清空y的值

{

x=Double.parseDouble(tf1.getText().trim());

str.setLength(0);//清空缓冲区以便接收新的另一个运算数

y=0d;

z=0;

}

else if(e2.getSource()==b20)//单击减号按钮获得x的值和z的值并清空y的值

{

x=Double.parseDouble(tf1.getText().trim());

str.setLength(0);

y=0d;

z=1;

}

else if(e2.getSource()==b15)//单击乘号按钮获得x的值和z的值并清空y的值

{

x=Double.parseDouble(tf1.getText().trim());

str.setLength(0);

y=0d;

z=2;

}

else if(e2.getSource()==b10)//单击除号按钮获得x的值和z的值并空y的值

{

x=Double.parseDouble(tf1.getText().trim());

str.setLength(0);

y=0d;

z=3;

}

else if(e2.getSource()==b26)//单击等号按钮输出计算结果

{

str.setLength(0);

switch(z)

{

case 0 : tf1.setText(""+(x+y));break;

case 1 : tf1.setText(""+(x-y));break;

case 2 : tf1.setText(""+(x*y));break;

case 3 : tf1.setText(""+(x/y));break;

}

}

else if(e2.getSource()==b24)//单击"."按钮输入小数

{

if(tf1.getText().trim().indexOf(′.′)!=-1)//判断字符串中是否已经包含了小数点

{

}

else//如果没数点有小

{

if(tf1.getText().trim().equals("0"))//如果初时显示为0

{

str.setLength(0);

tf1.setText((str.append("0"+e2.getActionCommand())).toString());

}

else if(tf1.getText().trim().equals(""))//如果初时显示为空则不做任何操作

{

}

else

{

tf1.setText(str.append(e2.getActionCommand()).toString());

}

}

y=0d;

}

else if(e2.getSource()==b11)//求平方根

{

x=Double.parseDouble(tf1.getText().trim());

tf1.setText("数字格式异常");

if(x0)

tf1.setText("负数没有平方根");

else

tf1.setText(""+Math.sqrt(x));

str.setLength(0);

y=0d;

}

else if(e2.getSource()==b16)//单击了"%"按钮

{

x=Double.parseDouble(tf1.getText().trim());

tf1.setText(""+(0.01*x));

str.setLength(0);

y=0d;

}

else if(e2.getSource()==b21)//单击了"1/X"按钮

{

x=Double.parseDouble(tf1.getText().trim());

if(x==0)

{

tf1.setText("除数不能为零");

}

else

{

tf1.setText(""+(1/x));

}

str.setLength(0);

y=0d;

}

else if(e2.getSource()==b3)//MC为清除内存

{

m=0d;

tf2.setText("");

str.setLength(0);

}

else if(e2.getSource()==b4)//MR为重新调用存储的数据

{

if(tf2.getText().trim()!="")//有记忆数字

{

tf1.setText(""+m);

}

}

else if(e2.getSource()==b5)//MS为存储显示的数据

{

m=Double.parseDouble(tf1.getText().trim());

tf2.setText("M");

tf1.setText("0");

str.setLength(0);

}

else if(e2.getSource()==b6)//M+为将显示的数字与已经存储的数据相加要查看新的数字单击MR

{

m=m+Double.parseDouble(tf1.getText().trim());

}

else//选择的是其他的按钮

{

if(e2.getSource()==b22)//如果选择的是"0"这个数字键

{

if(tf1.getText().trim().equals("0"))//如果显示屏显示的为零不做操作

{

}

else

{

tf1.setText(str.append(e2.getActionCommand()).toString());

y=Double.parseDouble(tf1.getText().trim());

}

}

else if(e2.getSource()==b0)//选择的是“BackSpace”按钮

{

if(!tf1.getText().trim().equals("0"))//如果显示屏显示的不是零

{

if(str.length()!=1)

{

tf1.setText(str.delete(str.length()-1,str.length()).toString());//可能抛出字符串越界异常

}

else

{

tf1.setText("0");

str.setLength(0);

}

}

y=Double.parseDouble(tf1.getText().trim());

}

else//其他的数字键

{

tf1.setText(str.append(e2.getActionCommand()).toString());

y=Double.parseDouble(tf1.getText().trim());

}

}

}

catch(NumberFormatException e){

tf1.setText("数字格式异常");

}

catch(StringIndexOutOfBoundsException e){

tf1.setText("字符串索引越界");

}

}

}

public static void main(String args[])

{

new Counter();

}

}

你在JAVA的环境中运行一下。

这题目也是我的作业，我运行的了。

关于ubuntu计算器程序的源代码问题

思路一：关于字符串扫描的问题

首先你要有一个词法分析的过程，把字符流转换为token流。每一个token是一个最小的、不可分割的单词（在这一步骤中，通常还需要同时过滤掉空格、回车、注释等和解析无关的内容）。例如：

2 操作数

+ 操作符

3215 操作数

× 操作符

......

思路二：关于计算

首先，要有一个对比两个操作符优先级的工具函数，

然后，要准备两个栈（FILO）：一个是操作数栈，一个是操作符栈。

每扫描到操作数时，压入操作数栈。

每扫描到操作符时，要与操作符栈栈顶的操作符，比较优先级。若优先级小，弹出一个操作符和两个操作数，进行计算，结算结果重新压入操作数栈；若优先级高，操作符直接入栈。

如此往复，最终操作数栈内残留的操作数即为计算结果（此时操作符栈应该已经清空）。

理财计算器源代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于理财算法计算器、理财计算器源代码的信息别忘了在本站进行查找喔。