四则运算的编译器是
目前最流行的C语言编译器有以下几种：
1、GNU Compiler Collection 或称GCC
GCC（GNU Compiler Collection，GNU编译器套件），是由 GNU 开发的编程语言编译器。它是以GPL许可证所发行的自由软件，也是 GNU计划的关键部分。
GCC原本作为GNU操作系统的官方编译器，现已被大多数类Unix操作系统（如Linux、BSD、Mac OS X等）采纳为标准的编译器，GCC同样适用于微软的Windows。GCC是自由软件过程发展中的着名例子，由自由软件基金会以GPL协议发布。
2、Microsoft C 或称 MS C
Microsoft C 是c语言的一种IDE（集成开发环境），常见的还有Microsoft Visual C++，Borland C++，Watcom C++ ,Borland C++ ，Borland C++ Builder,Borland C++ 3.1 for DOS,Watcom C++ 11.0 for DOS,GNU DJGPP C++ ，Lccwin32 C Compiler 3.1,High C,Turbo C等等......
3、Borland Turbo C 或称 Turbo C
Turbo C是美国Borland公司的产品，Borland公司是一家专门从事软件开发、研制的大公司。该公司相继推出了一套 Turbo系列软件, 如Turbo BASIC, Turbo Pascal, Turbo Prolog, 这些软件很受用户欢迎。
(1)四则运算的编译器是扩展阅读：
C编译的整个过程很复杂，大致可以分为以下四个阶段：
1、预处理阶段在该阶段主要完成对源代码的预处理工作，主要包括对宏定义指令，头文件包含指令，预定义指令和特殊字符的处理，如对宏定义的替换以及文件头中所包含的文件中预定义代码的替换等，总之这步主要完成一些替换工作，输出是同源文件含义相同但内容不同的文件。
2、编译、优化阶段编译就是将第一阶段处理得到的文件通过词法语法分析等转换为汇编语言。优化包括对中间代码的优化，如删除公共表达式，循环优化等；和对目标代码的生成进行的优化，如如何充分利用机器的寄存器存放有关变量的值，以减少内存访问次数。
3、汇编阶段将汇编语言翻译成机器指令。
4、链接阶段链接阶段的主要工作是将有关的目标文件连接起来，即将在一个文件中引用的符号同该符号在另外一个文件中的定义连接起来，使得所有的目标文件成为一个能够被操作系统装入执行的统一整体。
❷ int64的应用
不同的编译器对64位整数的扩展有所不同。 VCVC6.0的64位整数分别叫做__int64与unsigned __int64，其范围分别是[-2^63, 2^63)与[0,2^64)，即-9223372036854775808~9223372036854775807(10^19)与0~18446744073709551615(约1800亿亿)(10^20)。对64位整数的运算与32位整数基本相同，都支持四则运算与位运算等。当进行64位与32位的混合运算时，32位整数会被隐式转换成64位整数。但是，VC的输入输出与__int64的兼容就不是很好了，如果你写下这样一段代码：
1 __int64 a;
2 cin >> a;
3 cout << a;
那么，在第2行会收到“error C2679: binary '>>' : no operator defined which takes a right-hand operand of type '__int64' (or there is no acceptable conversion)”的错误；在第3行会收到“error C2593: 'operator <<' is ambiguous”的错误。那是不是就不能进行输入输出呢？当然不是，你可以使用C的写法：
scanf(%I64d,&a);
printf(%I64d,a);
就可以正确输入输出了。当使用unsigned __int64时，把I64d改为I64u就可以了。 OJ通常使用g++编译器。其64位扩展方式与VC有所不同，它们分别叫做long long 与 unsigned long long。处理规模与除输入输出外的使用方法同上。对于输入输出，它的扩展比VC好。既可以使用
1 long long a;
2 cin>>a;
3 cout<<a;
也可以使用
scanf(%lld,&a);
printf(%lld,a);
使用无符号数时，将%lld改成%llu即可。
最后补充一点：作为一个特例，如果你使用的是Dev-C++的g++编译器，它使用的是%I64d而非%lld。 变量类型：int64
数据范围：-9223372036854775808..9223372036854775807
可以直接read()输入,write()输出，不能用作循环变量。 vara:int64;begin{主程序}end;
❸ java:抽象类和接口实现四则运算器
import java.util.*;
interface yunsuan
{
public int jia();
public int jian();
public int cheng();
public int chu();
}
class Example implements yunsuan
{
int x,y;
public Example(int x,int y)
{
this.x=x;
this.y=y;
}
public int jia()
{
return x+y;
}
public int jian()
{
return x-y;
}
public int cheng()
{
return x*y;
}
public int chu()
{
return x/y;
}
}
public class ag
{
public static void main(String []args)
{
Scanner in=new Scanner(System.in);
System.out.println("输入第一个数");
int a=in.nextInt();
System.out.println("输入第二个数");
int b=in.nextInt();
System.out.println("输入运算符");
String c=in.next();
Example ys=new Example(a,b);
if(c.equals("+"))
{System.out.print(ys.jia());}
else if(c.equals("-"))
{System.out.print(ys.jian());}
else if(c.equals("*"))
{System.out.print(ys.cheng());}
else if(c.equals("/"))
{System.out.print(ys.chu());}
}
}
❹ MATLAB中怎么在编译器中定义一个四则运算函数
clccleara=round(rand*90)+10;b=round(rand*90)+10;c=input('请输入一个四则运算符号,请用单引号括起来');switchccase'+'d=a+b;case'-'d=a-b;case'*'d=a*b;case'/'d=a/b;endd示范：请输入一个四则运算符号,请用单引号括起来'*'d=7520
❺ 如何编写一个可以计算任意两个实数的四则运算,求余,乘方的C语言计算器
亲，要用什么编译器做呢，是只要代码还是？？？
❻ 请大家帮忙用C语言编写一个四则运算程序
你就用楼下的程序吧！！
/*** 一共包含四个文件 *************
| Symbol.h
| Stack.h
| Expression.h
| Expression.c
| 这里的代码考虑到通用性，对代码的可
| 重用性作了细致的考虑，略显冗余，核心算法:
| Expression.h里的函数STATUS EvaluateExpression(float*fResult,char*strExpression)
**********************************/
// --Expression.c
#include "Expression.h"
extern EXPRESSION_DEBUG;
STATUS EvaluateExpression(float*,char*);
void Usage(char *);
int HandleOptions(int,char **);
int main(int argc,char*argv[ ])
{
char strLine[30]={0};
float fResult=0;
/* handle the program options */
HandleOptions(argc,argv);
fprintf(stderr,"Input cls to clear the screen\n");
fprintf(stderr," debug to show stack change\n");
fprintf(stderr," nodebug to show no stack change\n");
fprintf(stderr," end to exit\n");
while(TRUE)
{
printf("Input:\n");
gets(strLine);
if(!strcmp(strLine,"end"))
break;
if(!strcmp(strLine,"cls")) {
system("cls");
continue;
}
if(!strcmp(strLine,"debug")){
EXPRESSION_DEBUG=TRUE;
continue;
}
if(!strcmp(strLine,"nodebug")){
EXPRESSION_DEBUG=FALSE;
continue;
}
EvaluateExpression(&fResult,strLine);
printf("Ans=%f\n",fResult);
}
return OK;
}
void Usage(char *programName)
{
fprintf(stderr,"%s usage:%s [-d][-h/?]\n",programName,programName);
fprintf(stderr,"-d Test program, calculate expression and\n");
fprintf(stderr," see changes in the stack at the same time.\n");
exit(OK);
}
/* returns the index of the first argument that is not an option; i.e.
does not start with a dash or a slash
*/
int HandleOptions(int argc,char *argv[])
{
int i,firstnonoption=0;
for (i=1; i< argc;i++) {
if (argv[i][0] == '/' || argv[i][0] == '-') {
switch (argv[i][1]) {
/* An argument -? means help is requested */
case '?':
case 'h':
case 'H':
Usage(argv[0]);
break;
case 'd':
case 'D':
EXPRESSION_DEBUG=TRUE;
break;
default:
fprintf(stderr,"unknown option %s\n",argv[i]);
break;
}
}
else {
firstnonoption = i;
break;
}
}
return firstnonoption;
}
//--Symbol.h
//--symbol.h - definitions/declarations for symbols used by other C Header files
#ifndef SYMBOL_H
#define SYMBOL_H
#define STACK_H
#define TRUE 1
#define OK 1
#define YES 1
#define FALSE 0
#define ERROR 0
#define NO 0
#define OVERFLOW -1
#ifndef NULL
#define NULL 0
#endif
typedef unsigned int UINT;
typedef int STATUS;
typedef int BOOL;
#endif /*SYMBOL_H*/
//--stack.h - definitions/declarations for stack operation
#ifndef STACK_H
#define STACK_H
#include "Symbol.h"
#include <malloc.h>
#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include <string.h>
#define S_CHAR 1
#define S_SHORT 2
#define S_INT 3
#define S_FLOAT 4
#define S_DOUBLE 5
//-- Stack.h
typedef struct tagNode
{
void*pData;
struct tagNode*pNext;
}Node,*PNode;
typedef struct tagStack
{
UINT uType;
/*1 char
*2 short/short int
*3 int
*4 float
*5 double
*/
UINT uLength;
struct tagNode*pFirst;
struct tagNode*pTop;
}Stack,*PStack;
STATUS InitStack(PStack pStack,UINT uType)
{
pStack->uType=uType;
pStack->uLength=0;
pStack->pFirst=pStack->pTop=NULL;
return OK;
}
STATUS ShowStack(PStack pStack)
{
PNode pNode=pStack->pFirst;
while(pNode)
{
switch(pStack->uType)
{
case S_CHAR: // char
printf("%c ",*(char*)(pNode->pData));break;
case S_FLOAT: // float
printf("%-4.1f ",*(float*)(pNode->pData));
}
pNode=pNode->pNext;
}
putchar(10);
return OK;
}
STATUS Push(PStack pStack,void*pData)
{
PNode pNode=(PNode)malloc(sizeof(Node));
if(!pNode)
{
printf("\nmalloc error!\n");
fflush(stdin);
getch();
exit(ERROR);
}
if(pStack->uType==1)
{
pNode->pData=(char*)malloc(sizeof(char));
*(char*)(pNode->pData)=*(char*)pData;
}
else if(pStack->uType==3)
{
pNode->pData=(int*)malloc(sizeof(int));
pNode->pData=(int*)malloc(sizeof(int));
*(int*)(pNode->pData)=*(int*)pData;
}
else if(pStack->uType==4)
{
pNode->pData=(float*)malloc(sizeof(float));
pNode->pData=(float*)malloc(sizeof(float));
*(float*)(pNode->pData)=*(float*)pData;
}
else if(pStack->uType==5)
{
pNode->pData=(double*)malloc(sizeof(double));
pNode->pData=(double*)malloc(sizeof(double));
*(double*)(pNode->pData)=*(double*)pData;
}
pNode->pNext=NULL;
if(!pStack->pTop)
pStack->pTop=pStack->pFirst=pNode;
else
{
pStack->pTop->pNext=pNode;
pStack->pTop=pNode;
}
pStack->uLength++;
return OK;
}
STATUS Pop(PStack pStack,void*pData)
{
PNode pPre=pStack->pFirst;
if(pStack->pTop!=pStack->pFirst)
while(pPre->pNext!=pStack->pTop)
pPre=pPre->pNext;
else
pPre=NULL;
if(pStack->uType==1)
*(char*)(pData)=*(char*)(pStack->pTop->pData);
else if(pStack->uType==3)
*(int*)(pData)=*(int*)(pStack->pTop->pData);
else if(pStack->uType==4)
*(float*)(pData)=*(float*)(pStack->pTop->pData);
else if(pStack->uType==5)
*(double*)(pData)=*(double*)(pStack->pTop->pData);
free(pStack->pTop->pData);
free(pStack->pTop);
pStack->pTop=pPre;
if(pPre)
pStack->pTop->pNext=NULL;
else
pStack->pFirst=NULL;
pStack->uLength--;
return OK;
}
STATUS GetTop(PStack pStack,void*pData)
{
if(pStack->uType==1)
*(char*)(pData)=*(char*)(pStack->pTop->pData);
else if(pStack->uType==3)
*(int*)(pData)=*(int*)(pStack->pTop->pData);
else if(pStack->uType==4)
*(float*)(pData)=*(float*)(pStack->pTop->pData);
else if(pStack->uType==5)
*(double*)(pData)=*(double*)(pStack->pTop->pData);
return OK;
}
STATUS DestroyStack(PStack pStack)
{
PNode pPre1,pPre2;
pPre1=pPre2=pStack->pFirst;
while(pPre1)
{
pPre1=pPre1->pNext;
free(pPre2->pData);
free(pPre2);
pPre2=pPre1;
}
pStack->pFirst=pStack->pTop=NULL;
pStack->uLength=0;
return OK;
}
#endif /* STACK_H */
//--Expresson.h
#ifndef EXPRESSION_H
#define EXPRESSION_H
#include "Stack.h"
typedef struct tagOptr
{
char cOptr;
UINT uPriority;
}Optr,*POptr;
BOOL EXPRESSION_DEBUG=FALSE;
Optr pOptr[8]={{0,7},{')',1},{'*',2},{'/',2},{'+',3},{'-',3},{'(',4},{'#',4}};
STATUS Operate(float*fTemp3,float fTemp1,char theta,float fTemp2)
{
switch(theta)
{
case '+':*fTemp3=fTemp1+fTemp2;break;
case '-':*fTemp3=fTemp1-fTemp2;break;
case '*':*fTemp3=fTemp1*fTemp2;break;
case '/':
if(fTemp2!=0)
*fTemp3=fTemp1/fTemp2;
else
{
printf("\n0 can not be divisor!\n\nPress any key to continue...\n");
fflush(stdin);
getch();
exit(ERROR);
}// else
break;
}
return OK;
}
int Precede(char cOptrTop,char cChar)
{
UINT i,j;
if(cOptrTop=='#'&&cChar=='#')
return 0;
if(cChar=='(')
return -1;
if(cChar==')')
if(cOptrTop=='(')
return 0;
else
return 1;
for(i=1;i<=pOptr[0].uPriority;i++)
if(pOptr[i].cOptr==cOptrTop)
{
i=pOptr[i].uPriority;
break;
}
for(j=1;j<=pOptr[0].uPriority;j++)
if(pOptr[j].cOptr==cChar)
{
j=pOptr[j].uPriority;
break;
}
if(i<=j)
return 1;
else
return -1;
return -2;
}
STATUS IsIn(char cChar)
{
if(cChar>='0'&&cChar<='9'||cChar=='.')
return YES;
return NO;
}
STATUS Debug(PStack stackOptr,PStack stackOpnd,char*strExpression,int i)
{
// --debug
if(EXPRESSION_DEBUG)
{
printf("-------------------------------\n");
printf("%s\n",strExpression);
printf("Optr:");
ShowStack(stackOptr);
printf("Opnd:");
ShowStack(stackOpnd);
}
return OK;
}
STATUS EvaluateExpression(float*fResult,char*strExpression)
{
char cChar='#',cOptrTop=0,theta=0;
float fTemp1,fTemp2,fTemp3,fTemp4;
int i=0,iTemp;
Stack stackOptr,stackOpnd;
InitStack(&stackOptr,S_CHAR);
InitStack(&stackOpnd,S_FLOAT);
Push(&stackOptr,&cChar);
GetTop(&stackOptr,&cOptrTop);
strcat(strExpression,"#");
if(strExpression[0]=='-'){
fTemp1=0;
Push(&stackOpnd,&fTemp1);
}
cChar=strExpression[0];
while(cChar!='#'||cOptrTop!='#')
{
Debug(&stackOptr,&stackOpnd,strExpression,i);
if(IsIn(cChar))
{
fTemp1=0;
fTemp3=10;
fTemp4=1;
while(IsIn(cChar))
{
if(cChar=='.'){
fTemp3=1;
cChar=strExpression[++i];
continue;
}
fTemp2=(float)(cChar-'0');
if(fTemp3==1)
{
iTemp=i;
while(IsIn(strExpression[i])){
fTemp2/=10;
i++;
}
i=iTemp;
}
fTemp1=fTemp1*fTemp3+fTemp2;
cChar=strExpression[++i];
}
Push(&stackOpnd,&fTemp1);
}
else
{
switch(Precede(cOptrTop,cChar))
{
case -1:Push(&stackOptr,&cChar);cChar=strExpression[++i];break;
case 0:Pop(&stackOptr,&cChar);cChar=strExpression[++i];break;
case 1:
Pop(&stackOptr,&theta);
Pop(&stackOpnd,&fTemp2);Pop(&stackOpnd,&fTemp1);
Operate(&fTemp3,fTemp1,theta,fTemp2);
Push(&stackOpnd,&fTemp3);
break;
}// switch
GetTop(&stackOptr,&cOptrTop);
}// else
}// while
Pop(&stackOptr,&cChar);
Debug(&stackOptr,&stackOpnd,strExpression,i);
GetTop(&stackOpnd,fResult);
DestroyStack(&stackOptr);
DestroyStack(&stackOpnd);
return OK;
}// EvaluateExpression
#endif // EXPRESSION_H
❼ 谁帮忙用switch编写一个简单的计算器，实现两个整型数的四则运算 。c语言
#include<stdio.h>
void main()
{
char ch;
int x,y,sum=0;
scanf("%d %c %d",&x,&ch,&y);
switch(ch)
{
case '+':sum=x+y;
break;
case '-':sum=x-y;
break;
case '*':sum=x*y;
break;
case '/':sum=x/y;
break;
}
printf("%d%c%d=%d",x,ch,y,sum);
getch();
}