编译算怎么算
㈠ 怎么用C++编译一个简单的计算器
我借鉴了别人的某计算器，因为你没有说多简易...我就找了个差不多的...
/*
程序名称:表达式计算器
编译环境:Microsoft Visual C++ 6.0
作者:吉林大学 计算机科学与技术学院 2006 罗泗勇
时间:200801
*/
/*
说明:
采用树形结构处理表达式,按优先级运算结果,一个加,减,乘,除或数值为一个节点
优先级如下:
函数: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=8;
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);
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;i<sizeof(NUM);i++)
{
if(c==NUM[i])
return true;
}
return false;
}
bool Isoperation(char c)
{
for(int i=0;i<sizeof(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;i<explen;i++)
{
char c=exp.at(i);
if(c=='(')
{
pri+=3;
stat=0;
}
else if(c==')')
{
pri-=3;
stat=0;
}
else if(Isoperation(c)) //操作符不会出现在表达式开头
{
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 //其他的当做函数处理
{
string function="";
while(i<explen && (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(i<temp.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(i<temp.size() && (ch=temp.at(i),! Isnum(ch)))
{
op+=ch;
type=1;
i++;
}
while(i<temp.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->PRI<=now_pri) //优先级低于当前优先级,树根方向 //最初写的 if(p->PRI<now_pri),9/3/3=9,错的
{
proot=new Node(p->Operation,p->PRI,1); //新的树根
proot->Left=root; //根的变换
proot->Right=new Node(' ',0,0,p->Next->value);
root=proot;
pbranch=proot; //右树枝的变换
//pbranch->Right=new Node(' ',0,0,p->Pre->value); //树枝右边取值
}
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->Right=new Node(' ',0,0,p->Next->value);
}
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(cin,exp).eof())
{
if(exp=="")
continue;
Unit * h=Analyse(exp);
h=Calc(h);
Node * root=Tree(h);
cout<<exp<<"="<<root->GetValue()<<endl;
}
return 0;
}
㈡ 用C语言编译数学运算
这个是我的实验报告，跟你的这个一样的。如果只要代码的话就看最后面的。我感觉应该算比较全面的。你看看，有什么具体要求可以提出来。
一、需求分析
1、 功能：疏如一行表达式，若表达式有误，则输出“表达式有错” ，否则计算出表达式的值并输出。 运算符包括加、减、乘、除、乘方、一目减。 括号均为小括号，但可以层层嵌套。操作数可以是浮点数，也包括有多个字母组成的变量。
2、 输入的形式为表达式，按回车结束。输入值的范围不超过浮点数的范围。含有变量，变量名由字母组成，大小写不限。
3、 若计算结果为整数，则输出整数，若含有小数，则输出浮点数。
二、概要设计
1、 总体思路，先读入一行表达式，用一个字符数组存储。然后依次读每个字符，进行判断。边读入边进行计算。程序中用到了两个栈，一个字符栈以及一个数字栈，分别用来存储运算符和数字，根据运算符的优先顺序进行计算。最后输出结果。
2、程序包括几个模块，主函数和几个基本函数。
说明几个函数：
bool stackempty(save1 s)用来判断操作数栈s是否为空。
void push(save1 &s,char e)若栈满则输出“栈已满”，否则将元素e入栈
void pop(save1 &s, char &e)若栈为空则输出“栈为空”，否则将栈顶元素赋给e
bool stackempty2(save2 s)用来判断运算符栈s是否为空。
void push2(save2 &s, char e)若运算符栈满则输出“栈已满”，否则将元素e入栈
void pop2(save2 &s, char &e)若栈为空则输出“栈为空”，否则将栈顶元素赋给e
int in(char e)返回运算符e在栈内的优先级别
int out(char e) 返回运算符e在栈外的优先级别
void count(char a,char ope, char b)将a、b进行相应的运算，并将运算结果入栈
3、具体操作步骤：
1、先读入一行表达式，用一个字符数组line[]存储
2、依次读入每个字符并进行处理同是进行表达式判错：
1. 遇数字，则继续判断下一个字符，直到下一个字符不是数字且不是小数点，若该数含有两个小以上数点，则表示输入错误。否则即可保证该操作数是完整的浮点数，然后将该数入操作数栈。
若数字不是表达式的最后一位，且数字后面跟的不是“+、-、*、/、^、)”，则为表达式错误
2. 遇运算符，则分两种情况：
1、若运算符为负号（该运算符为符号的情况有两种：一为负号在最开头，一为符号前面是“（” ），则先将0入操作数栈，然后再将负号入运算符栈。
2、该运算符不是负号则与运算符栈的栈顶元素比：
(1) 若栈顶元素优先级低， 新输入的运算符入栈。
(2) 若栈顶元素优先级高，
1) 从符号栈弹出一个运算符，
2) 从对象栈弹出一个/两个操作数，
3) 运算结果压入对象栈。
(3) 优先级相等，则栈顶元素出栈，与输入元素对消。
若“(、+、-、*、/、^”放在表达式最后面，则表达式错误
若“+、-、*、/、^”后面跟的不是数字或者变量，表达式错误
3、遇字母变量，则继续判断下一个字符，直到下一个字符不是字母变量，即可保证该变量是完整的，然后输出“请输入变量的值”，再将输入的变量值入操作数栈。
若变量后面跟的不是“+、-、*、/、^、)”，则表达式错误
4、若所读的该字符不是上述情况中的一种，则表达式错误
3、当将所有的字符都读一遍之后，若表达式正确的话，则必然不含有“（”或者“）”。即若运算符栈中含有“（”或者“）”，则表达式必错误。 再考虑表达式正确的情况：运算符栈可能为空，则操作符栈中必剩下一个操作数，即最后的结果。若不为空，则留在运算符栈中的运算符的优先级别从栈顶至栈底依次递减。故可从运算符栈顶开始弹出一个运算符，从操作数栈中弹出两个操作数进行运算，再将运算结果入操作数栈，一直循环至运算符栈为空。此时操作数栈剩下的唯一一个操作数就是运算结果。
三、结论及体会
1、实验结论
a)、实验完成了题目的要求，自己添加了对浮点数的操作，并进行判错。
b)、编写代码基本上能够满足编程规范的要求，代码的变量命名，以及注释的书写，基本能按照要求进行。
b)、将数据结构中的队列和堆栈的知识复习到，并且学会创新，在代码的编写中，学习了编程规范，学习了结构化编程。
2、实验体会
a)、通过本设计实验将数据结构中的堆栈和队列的知识复习到，并且能够自己设计一些东西，学会了在设计实验过程时的基本步骤。基本上能够有条理的解决这些问题。
b)、在试验中遇到了很多的问题，都是以前没有发现的，这些问题设计的方面很多，有以前的C++基础的，也有最近学习的数据结构的知识。通过实验的设计，让我发现了自己的不足。自己在学习知识上面的漏洞。自己在细节方面的考虑还不够全面，很多细节都是通过调试才发现的。比如刚开始时忘了考虑变量之前有负号的情况以及将整个式子读一遍之后，栈中的操作数可能还有剩，还得继续进行计算等。希望通过弥补这些发现的漏洞，提高自己的专业知识水平。
c)、设计过程中的解决问题的方法，让我明白了如何学习会更有效。如何学习才不会耽误太多的时间。也学会了解决问题的一般方法：向老师、同学请教，借助网络等等。
d)、实验过程中也走了很多的弯路，由于在开始设计的时候思路不时很清晰，对于一些问题不能很好的提出解决问题的方法，在设计过程中，代码总是重复的修改，在很多问题上，代码并不时最优的。相信在以后的学习中，随着知识的增多，问题会逐渐得到解决。
四、程序源代码
#include<iostream>
#include<cmath>
#include<cstdlib>
using namespace std;
#define MAX 1000
struct save1
{
float n[MAX];
int top;
}stack1;
struct save2
{
char n[MAX];
int top;
}stack2;
//stack1存储数字，stack2存储运算符号.
bool stackempty(save1 s)//判断是否为空
{
if (s.top== -1)
return 1;
else
return 0;
}
bool stackempty2(save2 s)//判断是否为空
{
if (s.top== -1)
return 1;
else
return 0;
}
void push(save1 &s,float e)//将e入栈
{
if(s.top==MAX-1)
{
cout<<"栈已满"<<endl;
return ;
}
s.top++;
s.n[s.top]=e;
}
void push2(save2 &s,char e)//将e入栈
{
if(s.top==MAX-1)
{
cout<<"栈已满"<<endl;
return ;
}
s.top++;
s.n[s.top]=e;
}
void pop(save1 &s,float &e)//将栈顶元素出栈，存到e中
{
if(s.top==-1)
{ cout<<"栈为空"<<endl; }
else
{e=s.n[s.top]; s.top--; }
}
void pop2(save2 &s,char &e)//将栈顶元素出栈，存到e中
{
if(s.top==-1)
{ cout<<"栈为空"<<endl; }
else
{e=s.n[s.top]; s.top--; }
}
int in(char e)//e在栈内的优先级别
{
if(e=='-' || e=='+') return 2;
if(e=='*' || e=='/') return 4;
if(e=='^') return 5;
if(e=='(') return 0;
if(e==')') return 7;
return -1;
}
int out(char e)//e在栈外的优先级别
{
if(e=='-' || e=='+') return 1;
if(e=='*' || e=='/') return 3;
if(e=='^') return 6;
if(e=='(') return 7;
if(e==')') return 0;
return -1;
}
void count(float a,char ope,float b)//进行计算并将计算结果入栈
{
float sum;
if(ope=='+') sum=a+b;
if(ope=='-') sum=a-b;
if(ope=='*') sum=a*b;
if(ope=='/') sum=a/b;
if(ope=='^') sum=pow(a,b);
push(stack1,sum);
}
int main()
{
int i=0,len,j,nofpoint,g=0;//len表示输入式子的长度。 g表示读入的字符是否是字母变量、数字以及运算符。
float a,b;//a、b用来存储操作数栈中弹出的操作数，便于代入函数中进行计算。
char line[MAX],operate,temp[20];
cout<<"请输入表达式"<<endl;
cin>>line;
len=strlen(line);
stack1.top=-1;//将栈置为空
stack2.top=-1;//将栈置为空
while(1)
{
g=0;
if(isdigit(line[i]))//若读入的字符为数字，则继续判断下一个字符，直到下一个字符不是数字或者不是小数点，即可保证该操作数是完整的小数，然后将该数入操作数栈。
{
j=0; g=1;
nofpoint=0;//记录所存的数中小数点的个数
while(isdigit(line[i]) || line[i]=='.')
{
if(line[i]=='.') nofpoint++;
temp[j++]=line[i];
i++;
if(i>=len) break;
}
if( nofpoint>1 || (i<len&&(line[i]!='-' && line[i]!='+' && line[i]!='*' && line[i]!='/' && line[i]!='^' && line[i]!=')')) )
{ cout<<"表达式有错"<<endl; return 0; }//所存数中含有不止一个小数点，或者数字后面跟的不是“+、-、*、/、^、)”，则为错误
temp[j]='\0';
b=atof(temp);
push(stack1,b);
if(i>=len) break;
}
else
{
if(line[i]=='-' || line[i]=='+' || line[i]=='*' || line[i]=='/' ||
line[i]=='^' || line[i]=='(' || line[i]==')' ) //若读入的字符为运算符的情况
{
g=1;
if(line[i]=='(' && i==len) { cout<<"表达式有错"<<endl; return 0; }// “(”放表达式最后面，错误
if(line[i]=='-' || line[i]=='+' || line[i]=='*' || line[i]=='/' || line[i]=='^')
{
if(i==len) { cout<<"表达式有错"<<endl; return 0; }//“+、-、*、/、^”放在表达式最后面，错误
if( (!isdigit(line[i+1])) && (!isalpha(line[i+1])) && line[i+1]!='(')//“+、-、*、/、^”后面跟的不是数字或者变量，错误
{ cout<<"表达式有错"<<endl; return 0; }
}
if(line[i]=='-' && (i==0 || line[i-1]=='(' ))//运算符是负号
{
push(stack1,0);
push2(stack2,line[i]);
i++;
}
else
{ //读入的运算符与运算符栈的栈顶元素相比，并进行相应的操作
if(in(stack2.n[stack2.top])<out(line[i])||stackempty2(stack2)) { push2(stack2,line[i]);i++;}
else
if(in(stack2.n[stack2.top])==out(line[i])) {i++; stack2.top--;}
else
if(in(stack2.n[stack2.top])>out(line[i]))
{
pop(stack1,a);
pop(stack1,b);
pop2(stack2,operate);
count(b,operate,a);
}
if(i>=len) break;
}
}
else
{
if(isalpha(line[i]))//读入的字符是字母变量的情况
{
g=1;
cout<<"请输入变量";
while( isalpha(line[i])) { cout<<line[i]; i++; }
cout<<"的值"<<endl;
cin>>b;
push(stack1,b);
if(i>=len) break;
if(line[i]!='-' && line[i]!='+' && line[i]!='*' && line[i]!='/' && line[i]!='^' && line[i]!=')')//变量后面跟的不是“+、-、*、/、^、)”，则为错误
{ cout<<"表达式有错"<<endl; return 0; }
}
}
}
if(g==0) { cout<<"表达式有错"<<endl; return 0; }//g=0表示该字符是不符合要求的字符
}
while(stack2.top!=-1)//读入结束后，继续进行操作，直到运算符栈为空
{
pop(stack1,a);
pop(stack1,b);
pop2(stack2,operate);
if(operate=='(' || operate==')') //括号多余的情况
{ cout<<"表达式有错"<<endl; return 0; }
count(b,operate,a);
}
cout<<stack1.n[stack1.top]<<endl;
return 0;
}
㈢ 用C语言编译计算长方形面积
#include<stdio.h>
void main()
{
float a,b;
printf("输入长方形的边长a,b, ");
scanf("%f%f",&a,&b);
printf("%f ",a*b);
}
#include<stdio.h>
float main()
{
float a,b;
printf("输入长方形的边长a,b, ");
scanf("%f%f",&a,&b);
Printf("%f ",2a+2b);
}
㈣ vs2012生成算不算是编译那如果不算是编译应该如何编译
其实生成一个可执行文件需要两个步骤
将多个 cpp 编译为 obj ，然后将多个 obj 连接为 1 个 exe
vs中的生成就是连接过程，编译在生成按钮的左侧，叫做 compile ，生成叫做 build
不过因为生成需要预先编译为 obj ，所以直接点击 build 也会预先编译。
类似的还有执行 execute ，你即便不手编译生成，他也会提示你先进行这一步骤。
㈤ 编译程序和解释程序都是什么意思
1、编译程序是把用高级程序设计语言或计算机汇编语言书写的源程序，翻译成等价的机器语言格式目标程序的翻译程序，属于采用生成性实现途径实现的翻译程序。编译程序以高级程序设计语言书写的源程序作为输入，而以汇编语言或机器语言表示的目标程序作为输出；编译出的目标程序通常还要经历运行阶段，以便在运行程序的支持下运行，加工初始数据，算出所需的计算结果。
2、解释程序是高级语言翻译程序的一种，它将源语言书写的源程序作为输入，解释一句后就提交计算机执行一句，并不形成目标程序。就像外语翻译中的“口译”一样，说一句翻一句，不产生全文的翻译文本。
(5)编译算怎么算扩展阅读：
编译程序的实现算法较为复杂。这是因为它所翻译的语句与目标语言的指令不是一一对应关系,而是一多对应关系;同时也因为它要处理递归调用、动态存储分配、多种数据类型，以及语句间的紧密依赖关系。但是，由于高级程序设计语言书写的程序具有易读、易移植和表达能力强等特点，编译程序广泛地用于翻译规模较大、复杂性较高、且需要高效运行的高级语言书写的源程序。
㈥ C#中编译是用来做什么的，在VS2008中怎么操作才算编译编译和运行的区别是什么
源码生成二进制文件就是编译，但还不能运行，要与系统库链接，生成该系统平台上的可执行文件，如，你打开记事本，这个叫运行，记事本这个程序已经编译生成好了，你可以直接运行。在 VS里封装了功能，就是生成，或像播放按钮的工具
㈦ 编译原理中(10)*怎么算
(10)*为任意个10的串，即
㈧ 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，对用户输入出错提示的不够。