如何用程序的构造方法描述算式

① 如何用C语言数据结构的格式实现简单的算术表达式求值程序

用栈把中缀表达式(输入简渣的式子）按优先级转为后缀表达式（逆波兰式，即运算符在前，操作数在后），再利用栈变计算边保存结果用于下一步计算，高咐神最后算出式子的答案
以下代码输入一个式子（以
=
作为输入结束标志），输出结果，负数如-3用0-3表示，支持高位运算
#include
<stdio.h>
#include
<戚亏stdlib.h>
#include
<math.h>
#include
<malloc.h>
#define
OK
1
#define
ERROR
-1
typedef
char
SElemType;
typedef
char
Status;
#define
STACK_INIT_SIZE
100000
#define
STACKINCREMENT
2
struct
SqStack
{
SElemType
*base;
SElemType
*top;
int
stacksize;
};
struct
SqStack1
{
int
*base;
int
*top;
int
stacksize;
};
SqStack
OPTR;
SqStack1
OPND;
char
Precede(char
c1,char
c2)
{
if(c1=='+'
||
c1=='-')
{
if(c2=='+'
||
c2=='-'
||
c2==')'
||
c2=='=')
return
'>';
else
return
'<';
}
else
if(c1=='*'
||
c1=='/')
{
if(c2=='(')
return
'<';
else
return
'>';
}
else
if(c1=='(')
{
if(c2==')')
return
'=';
else
return
'<';
}
else
if(c1==')')
return
'>';
else
if(c1=='=')
{
if(c2=='=')
return
'=';
else
return
'<';
}
else
return
'\0';
}
int
In(char
c)
{
if(c=='+'
||
c=='-'
||
c=='*'
||
c=='/'
||
c=='('
||
c==')'
||
c=='=')
return
1;
else
return
0;
}
int
Operrate(int
m,char
b,int
n)
{
switch(b)
{
case
'+':return
m+n;
case
'-':return
m-n;
case
'*':return
m*n;
case
'/':return
m/n;
}
return
0;
}
//操作数
int
InitStack1(SqStack1
&S)
{
S.base=(int
*)malloc(STACK_INIT_SIZE*sizeof(int));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return
OK;
}
int
Push1(SqStack1
&S,int
e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(int
*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREMENT;
}
*S.top++=e;
return
OK;
}
int
Pop1(SqStack1
&S,int
&e)
{
if(S.top==S.base)
return
ERROR;
e=*
--S.top;
return
OK;
}
int
GetTop1(SqStack1
S)
{
if(S.top==S.base)
return
ERROR;
return
*(S.top-1);
}
//算符
int
InitStack(SqStack
&S)
{
S.base=(SElemType
*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return
OK;
}
int
Push(SqStack
&S,SElemType
e)
{
if(S.top-S.base>=S.stacksize)
{
S.base=(SElemType
*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
S.top=S.base+S.stacksize;
S.stacksize=S.stacksize+STACKINCREMENT;
}
*S.top++=e;
return
OK;
}
int
Pop(SqStack
&S,SElemType
&e)
{
if(S.top==S.base)
return
ERROR;
e=*
--S.top;
return
OK;
}
Status
GetTop(SqStack
S)
{
if(S.top==S.base)
return
ERROR;
return
*(S.top-1);
}
int
Calculate()
{
char
c,theta,p;
int
a,b,i=0,ans,x;
InitStack(OPTR);
Push(OPTR,'=');
InitStack1(OPND);
c=getchar();
while(c!='='
||
GetTop(OPTR)!='=')
{
if(!In(c)
&&
c>='0'
&&
c<='9')
{
Push1(OPND,c-'0');
c=getchar();
while(c>='0'
&&
c<='9')
{
Pop1(OPND,x);
Push1(OPND,x*10+c-'0');
c=getchar();
}
}
else
if(In(c))
{
switch(Precede(GetTop(OPTR),c))
{
case
'<':
Push(OPTR,c);
c=getchar();
break;
case
'=':
Pop(OPTR,p);
c=getchar();
break;
case
'>':
Pop(OPTR,theta);
Pop1(OPND,b);
Pop1(OPND,a);
ans=Operrate(a,theta,b);
Push1(OPND,ans);
break;
}
}
else
{
c=getchar();
}
}
return
GetTop1(OPND);
}
int
main()
{
int
ans;
ans=Calculate();
printf("%d\n",ans);
return
0;
}

② 谁能帮我用c语言里的if-else-if结构编个简单的计算器,实现两个整数的四则运算

直接输入算式而得到结果的程序思路如下：
统计所输洞做入的算式里到底包括哪一晌颤此种运算符，比方说
for (i=0;i<=a;i++) //这里宴迅a表示所输入的字符总长度
{
if inp[i]="+" //这里inp表示你字符存储的数组名
tt=1;
if inp[i]="-"
tt=2;
if inp[i]="*"
tt=3
if inp[i]="/"
tt=4;
}
if tt=1
{将符号两边的数进行加法运算
}

………后面的自己写

不过这种好像不算好。提供第二种思路：
这次是要求输入一个数，然后选择运算符号，再输第二个数

scanf(%d,a); // scanf的用法好像是这样的吧？忘记了
printf("请选择要进行的运算：1 for +;2 for -; 3 for * ; 4for /");
scanf(%d,b);
printf("input the second number,please);
scanf (%d,c)；
if (b==1)
{ 做加法运算} //自己写出代码
else if (b==2) ………后面的自己写吧。

好了，写了这么多，给我加点分吧！！！
如果还不会，QQ我：408899168

③ 算法可以使用哪些描述方式，各有什么优势

算法的描述方式有：自然语言，流程图，伪代码等。

1、自然语言的优势：自然语言即人类语言，描述的算法通俗易懂，不用专门的训练，较为灵活。

2、流程图的优势：流程图描述的算法清晰简洁，容易表达选择结构，不依赖于任何具体的计算机和计算机程序设计语言，从而有利于不同环境的程序设计。

3、伪代码的优势：回避了程序设计语言的严格、烦琐的书写格式，书写方便，同时具备格式紧凑，易于理解，便于向计算机程序设计语言过渡的优点。

(3)如何用程序的构造方法描述算式扩展阅读：

算法使用伪代码的目的是使被描述的算法可以容易地以任何一种编程语言实现。

因此，伪代码必须结构清晰、代码简单、可读性好，并且类似自然语言。 介于自然语言与编程语言之间，以编程语言的书写形式指明算法职能。

伪代码只是像流程图一样用在程序设计的初期，帮助写出程序流程。简单的程序一般都不用写流程、写思路，但是复杂的代码，还是需要把流程写下来，总体上去考虑整个功能如何实现。

④ 编写一个循环结构的程序，使之能计算下面各算式：. 1+2+3…+99+100= 1+3+6+9+…+297+300=

FOR…NEXT语句
FOR…NEXT的语句格式为：
FOR <循环变量>=<初值> TO <终值> STEP <步长>
<循环体>
NEXT <循环变量>
For…Next语句运行的流程如图3-6.2所示。
图3-6.2 循环结构程序流程图
例如，下面是一个求1+2+3+…+99+100的简单程序：
Dim counter,nSum
nSum=0
For counter=1 to 100 Step 1
nSum = nSum + counter
Next counter
程序运行的结果是，变量nSum的值变为5050，变量counter的值变为101.
FOR与NEXT是一对语句，必须成对出现，循环变量用于控制循环体的循环，循环的次数由初值、终值与步长决定。整个循环的过程如下：
①、 把初值赋给循环变量
②、 判断循环变量是否超过终值，如果超过则执行第⑥步，否则执行第③步
③、 执行循环体
④、 循环变量加上步长再赋值给循环变量
⑤、 重复执行第②步
⑥、 离开循环，继续执行循环语句后面的语句

下面就利用For…Next语句来制作飞机飞行的程序，操作步骤如下：
步骤1：新建一个工程。
步骤2：在窗体上新建一个Image控件，用于显磨者手示飞机，名称为Image1。
步骤3：在窗体上新建三个CommandButton控件，将它们的Caption属性分别改为“复位”、“起飞”、“退出”。
步骤4：编写程序代码。
对“起飞”按钮Command2的Click事嫌陆件编写如下代码：
Private Sub Command2_Click()
For i = 1 To 3300
For j = 1 To 50000
Next
nLeft = nLeft + 2
nTop = nTop + 1
Image1.Left = nLeft
Image1.Top = nTop
Next
End Sub
在上面的程序中，使用了如下语句：
For j = 1 To 50000
Next
它的作用是控制飞机瞎嫌的飞行速度。将循环的终值减小，飞机就飞得快；增大，飞机就飞得慢。
在循环语句中执行 Exit For 语句，可以退出循环，使程序跳到Next之后的语句继续执行

⑤ JAVA构造方法

构造方法必须满足以下语法规则：

(1) 方法名必须与类名相同。

(2)不要声明返回类型。

(3)不能被static、final、synchronized、abstract和native修饰。构造方法不能被子类继承，所以用final和

abstract修饰没有意义。构造方法用于初始化一个新建的对象，所以用static修饰没有意义。多个线程不会同时创建内存地址相同的同一个对象，因此用synchronized修饰没有必要。此外，Java语言不支持native类型的构造方法。

例：

public class Sample {

private int x;

public Sample() { // 不带参数的构造方法

this(1);

}

public Sample(int x) { //带参数的构造方法

this.x=x;

}

public int Sample(int x) { //不是构造方法

return x++;

}

}

拓展资料：

构造方法的访问级别

构造方法可以处于public、protected、默认和private这四种访问级别之一。本节着重介绍构造方法处于private级别的意义。

当构造方法为private级别，意味着只能在当前类中访问它：在当前类的其他构造方法中可以通过this语句调用它，此外还可以在当前类的成员方法中通过new语句调用它。

在以下场合之一，可以把类的所有构造方法都声明为private类型。

（1）在这个类中仅仅包含了一些供其他程序调用的静态方法，没有任何实例方法。其他程序无需创建该类的实例，就能访问类的静态方法。例如 java.lang.Math类就符合这种情况，在Math类中提供了一系列用于数学运算的公共静态方法，为了禁止外部程序创建Math类的实例， Math类的惟一的构造方法是private类型的：

private Math(){}

abstract类型的类也不允许实例化。也许你会问，把Math类定义为如下abstract类型，不是也能禁止Math类被实例化吗？

public abstract class Math{…}

如果一个类是抽象类，意味着它是专门用于被继承的类，可以拥有子类，而且可以创建具体子类的实例。而JDK并不希望用户创建Math类的子类，在这种情况下，把类的构造方法定义为private类型更合适。

（2）禁止这个类被继承。当一个类的所有构造方法都是private类型，假如定义了它的子类，那么子类的构造方法无法调用父类的任何构造方法，因此会导致编译错误。把一个类声明为final类型，也能禁止这个类被继承。这两者的区别是：

1)如果一个类允许其他程序用new语句构造它的实例，但不允许拥有子类，那就把类声明为final类型。

2)如果一个类既不允许其他程序用new语句构造它的实例，又不允许拥有子类，那就把类的所有构造方法声明为private类型。

由于大多数类都允许其他程序用new语句构造它的实例，因此用final修饰符来禁止类被继承的做法更常见。

（3）这个类需要把构造自身实例的细节封装起来，不允许其他程序通过new语句创建这个类的实例，这个类向其他程序提供了获得自身实例的静态方法，这种方法称为静态工厂方法。

参考资料：java 构造函数

⑥ 用c或c++编写一个具有计算器功能的程序,要求一次性输入一行要求算式，输入“=”输出结果，有什么好的思路

可以用2叉树写。

定义运算式结构体类型，比如：

typedefstructyunsuan
{
//如果是单一运算，比如1+2，那么num1=1；num2=2；
intnum1;//左儿子运算符为0的时候直接取该值
intnum2;//右儿子运算符为0的时候直接取该值，为NULL说明只有一个数值运算
structyunsuan*father;//父亲：如果上层还有运算式，指向上层
structyunsuan*brother;//兄弟：如果同级还有其他运算式，指向该运算式结构
//如果是复合运算，为其创建左儿子，右儿子，指向儿子，并让儿子指向父扒春亲
structyunsuan*left;//左儿子
structyunsuan*right;//右儿子
charfh;//运算符号
}YS;

根据优先级解析多运算符的式子，比如2^2+（√4-1）。

从运算顺序最低的运算符号开始先找到'+'，创建树顶点结构体,fh='+';father=NULL；brother=NULL；left=（2^2）的结构体；right=（√4-1）的结构体；

（2^2）的结构体：fh='^';num1=2；num2=2；father=最顶端的结构体；brother=（竖此敏√4-1）的结构体；left=新建节点fh置0；right=新建节点fh置0；

（√4-1）的结构体：fh='-';num2=1；father=最顶端的结构体；brother=（2^2）的结构体；left=√4的结构体；right=新余枝建节点fh置0；

√4的结构体：fh='√';num1=4；father=（√4-1）的结构体；brother=NULL；left=新建节点fh置0；right=NULL；

依次类推，以上只是说明树形结构建立。

你解析字符串，从运算顺序最后的字符开始拆分并创建树的最顶层节点，然后依次往下建立树。

最后可以用递归函数或循环，遍历树各节点进行运算。

⑦ 如何用c语言实现：输入一个算式，然后在程序中使用。

程序是激蠢不带高认算式蠢铅尺的。你只能把它变为系数输入才可以。如ax*x+bx+c，你输入a,b,c。直接输算式没意义。归根到底，程序只能做你设计好的事情。想让它认算式，你要把你的算式归纳成只有系数的东西，或者其它有规律的东西。