三、实验环境
C或C＋＋语言编程环境实现。
四、实验原理和实现过程<算法描述）
1.实验原理
<1）合取：
二元命题联结词。
将两个命题P、Q联结起来，构成一个新的命题P∧Q,读作P、Q的合取,也可读作P与Q。
这个新命题的真值与构成它的命题P、Q的真值间的关系为只有当两个命题变项P=T,Q=T时方可P∧Q=T,而P、Q只要有一为F则P∧Q=F。
这样看来，P∧Q可用来表示日常用语P与Q,或P并且Q。
<2）析取：
二元命题联结词。
将两个命题P、Q联结起来，构成一个新的命题P∨Q,读作P、Q的析取,也可读作P或Q。
这个新命题的真值与构成它的命题P、Q的真值间的关系为只有当两个命题变项P=F,Q=F时方可P∨Q=F,而P、Q只要有一为T则P∨Q=T。
这样看来，P∨Q可用来表示日常用语P或者Q。
<3）条件：
二元命题联结词。
将两个命题P、Q联结起来，构成一个新的命题P→Q,读作P条件Q,也可读作如果P，那么Q。
这个新命题的真值与构成它的命题P、Q的真值间的关系为只有当两个命题变项P=T,Q=F时方可P→Q=F,其余均为T。
<4）双条件：
二元命题联结词。
将两个命题P、Q联结起来，构成一个新的命题P←→Q,读作P双条件于Q。
这个新命题的真值与构成它的命题P、Q的真值间的关系为当两个命题变项P=T,Q=T时方可P←→Q=T,其余均为F。
<5）真值表:
表征逻辑事件输入和输出之间全部可能状态的表格。
列出命题公式真假值的表。
通常以1表示真，0表示假。
命题公式的取值由组成命题公式的命题变元的取值和命题联结词决定，命题联结词的真值表给出了真假值的算法。
真值表是在逻辑中使用的一类数学表，用来确定一个表达式是否为真或有效。
<6）主范式：
主析取范式：
在含有n个命题变元的简单合取式中,若每个命题变元与其否定不同时存在,而两者之一出现一次且仅出现一次,称该简单合取式为小项。
由若干个不同的小项组成的析取式称为主析取范式。
与A等价的主析取范式称为A的主析取范式。
任意含n个命题变元的非永假命题公式A都存在与其等价的主析取范式,并且是惟一的。
主合取范式：
在含有n个命题变元的简单析取式中,若每个命题变元与其否定不同时存在,而两者之一出现一次且仅出现一次,称该简单析取式为大项。
由若干个不同的大项组成的合取式称为主合取范式。
与A等价的主合取范式称为A的主合取范式。
任意含n个命题变元的非永真命题公式A都存在与其等价的主合取范式,并且是惟一的。
2.实验过程
<1）A题部分，首先是对各个输入量的处理，要确定输入的为0或1，否则则为出错，接下来就是运算处理，在C语言中本身支持的有与或非这三种，可以用!
&&,||来表示，而在这个实验中，不是与或非的可以通过转化而变为与或非的形式，具体流程图如下：
<2）B，C题部分，首先是输入一个合理的式子，然后从式子中查找出变量的个数，开辟一个二进制函数，用来生成真值表，然后用函数运算，输出结果，并根据结果归类给范式，最后输出范式。
函数部分，主要是3个函数，一个为真值表递加函数，通过二进制的加法原理递进产生，一个为分级运算函数，这个函数是通过判断括号，选出最内级括号的内容执行运算函数，这样一级一级向外运算，最后得出最终结果，剩下一个为主运算函数，按照运算符号的优先级按顺序进行运算，如先将所有非运算运算完，再执行与运算。
如此运算。
五、实验数据及结果分析
题A：
进入界面
正确运算结果
错误控制和输入正确后
退出
结果分析：
这道题比较简单，主要是读取值并进行计算，同时要注意输入的值要是0或1，如果不是，则进行错误提示，并进行重新输入。
B,C题：
欢迎界面
非运算
与运算
或运算
蕴含运算
等值运算
综合运算
带括号的综合运算
结果分析：
B,C题由于本身关系比较密切，故我直接将两个做在了一起，这个程序从功能上来说，达到了题目要求的各个功能，可以运算与，或，非，蕴含，等值条件组成的表达式，并且支持括号运算，所以，总体上来说，虽然还有一些不完善的部分，但是整体是比较可以的。
六、源程序清单
A题部分源代码：
#include
main（>
{
inta[3]。
inti=-1,j=-1。
chars。
tt:
printf（"***************************************\n">。
//标语
printf（"****\n">。
printf（"**欢迎进入逻辑运算软件**\n">。
printf（"****\n">。
printf（"***************************************\n\n">。
mm:
printf（"\n请输入P的值<0或1）,以回车结束:
">。
scanf（"%d",&i>。
//读取P的值
if（i==0||i==1>。
//校验输入的P值是否在允许范围内，出错则重新输入
else
{
printf（"\nP的值输入有误，请重新输入">。
gotomm。
}
nn:
printf（"\n请输入Q的值<0或1）,以回车结束:
">。
scanf（"%d",&j>。
//读取Q的值
if（j==0||j==1>。
//校验输入的Q值是否在允许范围内，出错则重新输入
else
{
printf（"\nq的值输入有误，请重新输入">。
gotonn。
}
a[0]=i&&j。
//与运算
a[1]=i||j。
//或运算
a[2]=（!
i>||j。
//蕴含运算，将其转化为与或非形式
a[3]=（（!
i>||j>&&（（!
j>||i>。
//等值运算，将其转化为与或非形式
printf（"\n\n合取：
\nP/\\Q=%d\n",a[0]>。
//输出结果
printf（"析取：
\nP\\/Q=%d\n",a[1]>。
printf（"条件：
\nP->Q=%d\n",a[2]>。
printf（"双条件：
\nP<->Q=%d\n",a[3]>。
bb:
printf（"\n是否继续运算？
。
//询问是否继续操作
scanf（"%s",&s>。
if（s=='y'||s=='n'>
{
if（s=='y'>
{
system（"cls">。
//清屏
gotott。
//返回顶层
}elseprintf（"欢迎下次再次使用！
">。
//退出
}else
{printf（"输入错误，请重新输入\n">。
//错误校验
gotobb。
}
}
BC题部分源代码：
#include"stdio.h"
#include"stdlib.h"
#include"string.h"
#include"conio.h"
#include"math.h"
#defineN50
voidpanduan（intb[N],intf>。
//赋值函数
inttkh（charsz[N],charccu[N],inticu[N],inth0>。
//分级运算函数
intfkh（charsz[N],charccu[N],inticu[N],inth0>。
//主运算函数
main（>
{
inti1,i2,d=1,icu[N],kh=0,jg,j=0,h0。
//icu[N]用于存放变量值,kh括号计数,jg存放结果
intbj=0,hq[N],h=0,x=0,xq[N]。
//hq[N]存放合取结果xq[N]存放析取结果
charsz[N],ccu[N],sz0[N],s。
//sz[N]存放式子,ccu[N]存放变量,sz0[N]也是用于存放式子
hq[0]=-1。
xq[0]=-1。
printf（"***************************************\n">。
//标语
printf（"****\n">。
printf（"**欢迎进入逻辑运算软件**\n">。
printf（"**（可运算真值表，主范式，支持括号>**\n">。
printf（"****\n">。
printf（"**用!
表示非**\n">。
printf（"**用&表示与**\n">。
printf（"**用|表示或**\n">。
printf（"**用^表示蕴含**\n">。
printf（"**用~表示等值**\n">。
printf（"****\n">。
printf（"***************************************\n\n">。
printf（"请输入一个合法的命题公式:
\n">。
//输入式子
gets（sz>。
//读取式子
strcpy（sz0,sz>。
//复制式子
for（i1=0。
i1。
i1++>
{
if（sz[i1]=='>'||sz[i1]=='（'>//存储括号数量
kh++。
if（sz[i1]>='a'&&sz[i1]<='z'||sz[i1]>='A'&&sz[i1]<='Z'>
{
for（i2=0。
i2i2++>//判断并储存变量。
if（ccu[i2]==sz[i1]>//去除重复变量
d=0。
if（d==1>
{
ccu[j]=sz[i1]。
j++。
}
d=1。
}
}
printf（"\nd该式子中的变量个数为：
%d\n",j>。
//输出变量个数
h0=j。
printf（"\n输出真值表如下：
\n\n">。
//输出真值表表头
for（i1=0。
i1i1++>
printf（"%c",ccu[i1]>。
printf（"">。
puts（sz>。
printf（"\n">。
for（i1=0。
i1i1++>///////先将所有的变量赋值为零。
icu[i1]=0。
for（i2=0。
i2i2++>//输出真值表前项
printf（"%d",icu[i2]>。
jg=tkh（sz,ccu,icu,h0>。
//用函数求结果
if（jg==0>//结果为0，合取加1
hq[h++]=bj。
else//否则，析取加1
xq[x++]=bj。
printf（"%d\n",jg>。
//输出运算结果
strcpy（sz,sz0>。
for（i1=0。
i1<（int>pow（2,j>-1。
i1++>
{
++bj。
panduan（icu,j-1>。
//赋值变量
jg=tkh（sz,ccu,icu,h0>。
if（jg==0>//结果为0，合取加1
hq[h++]=bj。
else//否则，析取加1
xq[x++]=bj。
strcpy（sz,sz0>。
//恢复被修改的数组。
for（i2=0。
i2i2++>
printf（"%d",icu[i2]>。
//输出真值表前项
printf（"%d\n",jg>。
//输出运算结果
}
if（hq[0]==-1>//不存在合取范式时
printf（"\n该命题公式不存在主合取范式。
\n">。
else
{
printf（"\n该命题公式的主合取范式：
\n\t">。
for（i1=0。
i1i1++>
{
if（i1>0>//判断并添加符号
printf（"\\/">。
printf（"M（%d>",hq[i1]>。
//输出主合取范式
}
}
if（xq[0]==-1>//不存在析取范式时
printf（"\n该命题公式不存在主析取范式。
\n">。
else
{
printf（"\n\n该命题公式的主析取范式：
\n\t">。
for（i1=0。
i1i1++>
{
if（i1>0>//判断并添加符号
printf（"/\\">。
printf（"m（%d>",xq[i1]>。
//输出主析取范式
}
}
printf（"\n">。
printf（"\n欢迎下次再次使用！
\n">。
//结束
getch（>。
}
voidpanduan（intb[N],intf>//二进制赋值。
{
inti。
i=f。
if（b[f]==0>//加1
b[f]=1。
else//进位
{
b[f]=0。
panduan（b,--i>。
}
}
inttkh（charsz[N],charccu[N],inticu[N],inth0>//分级运算函数
{
inti,j,h,s,kh=0,wz[N],a。
charxs1[N],ckh[N]。
//xs1用来保存括号内的字符ckh用来保存括号。
s=strlen（sz>。
for（i=0。
ii++>
if（sz[i]=='（'||sz[i]=='>'>//判断括号
{
wz[kh]=i。
//存储括号位置
ckh[kh]=sz[i]。
//存储括号类型
kh++。
}
if（kh==0>
returnfkh（sz,ccu,icu,h0>。
//如果无括号，直接运行
else
{
for（i=0。
ii++>
if（ckh[i]=='>'>//找到第一个）
break。
for（j=wz[i-1]+1,h=0。
jj++,h++>//存储最内级括号中的内容
xs1[h]=sz[j]。
xs1[h]='\0'。
a=fkh（xs1,ccu,icu,h0>。
//运行最内级括号的式子，得到结果
if（a==1>//判断并存储结果
sz[wz[i-1]]=1。
else
sz[wz[i-1]]=-2。
for（j=wz[i-1]+1。
jj++>//将括号后内容前移
sz[j]=sz[j+wz[i]-wz[i-1]]。
sz[j]='\0'。
returntkh（sz,ccu,icu,h0>。
//循环执行
}
}
intfkh（charsz[N],charccu[N],inticu[N],inth0>//主运算函数
{
inti,h=0,j=0,j1=0,j2=0,j3=0,j4=0,j5=0,i1,i2,p1=-1,p2=-1,s。
chardt[N]。
s=strlen（sz>。
if（s==1>
if（sz[0]==-2>//判断是否是最后一项
return0。
else
return1。
//1就是sz[0]的值、
else
{
for（i=0。
ii++>//先处理非
if（sz[i]=='!
'>
{
for（i1=0。
i1i1++>
if（sz[i+1]==ccu[i1]>//将变量赋值并给P1
p1=icu[i1]。
if（sz[i+1]==-2>//如果是前运算结果的0，则P1等于0
p1=0。
if（p1==-1>//如果是数字，直接给P1
p1=sz[i+1]。
dt[j+2]=!
p1。
//非运算
sz[i]=j+2。
j++。
p1=0。
for（i1=i+1。
i1i1++>
sz[i1]=sz[i1+1]。
//将后续式子前移一项
}
p1=-1。
j1=j。
for（i=0。
ii++>//处理与
if（sz[i]=='&'>
{
for（i1=0。
i1i1++>
{
if（sz[i-1]==ccu[i1]>//将变量赋值并给P1
p1=icu[i1]。
if（sz[i+1]==ccu[i1]>//将变量赋值并给P2
p2=icu[i1]。
}
for（i2=2。
i2i2++>
{
if（sz[i-1]==i2>//如果为前计算结果，将结果赋值并给P1
p1=dt[i2]。
if（sz[i+1]==i2>//如果为前计算结果，将结果赋值并给P2
p2=dt[i2]。
}
if（sz[i-1]==-2>//如果是前运算结果的0，则P1等于0
p1=0。
if（sz[i+1]==-2>//如果是前运算结果的0，则P2等于0
p2=0。
if（p1==-1>//如果是数字，直接给P1
p1=（int>（sz[i-1]>。
if（p2==-1>//如果是数字，直接给P2
p2=（int>（sz[i+1]>。
dt[j+2]=p1&&p2。
//与运算
sz[i-1]=j+2。
j++。
j2++。
p1=-1。
p2=-1。
for（i1=i。
i1i1++>//将后续式子前移两项
sz[i1]=sz[i1+2]。
i=i-1。
}
for（i=0。
ii++>//处理或。
if（sz[i]=='|'>
{
for（i1=0。
i1i1++>
{
if（sz[i-1]==ccu[i1]>//将变量赋值并给P1
p1=icu[i1]。
if（sz[i+1]==ccu[i1]>//将变量赋值并给P2
p2=icu[i1]。
}
for（i2=2。
i2i2++>
{
if（sz[i-1]==i2>//如果为前计算结果，将结果赋值并给P1
p1=dt[i2]。
if（sz[i+1]==i2>//如果为前计算结果，将结果赋值并给P2
p2=dt[i2]。
}
if（sz[i-1]==-2>//如果是前运算结果的0，则P1等于0
p1=0。
if（sz[i+1]==-2>//如果是前运算结果的0，则P2等于0
p2=0。
if（p1==-1>//如果是数字，直接给P1
p1=sz[i-1]。
if（p2==-1>//如果是数字，直接给P2
p2=sz[i+1]。
dt[j+2]=p1||p2。
//或运算
sz[i-1]=j+2。
j++。
j3++。
p1=-1。
p2=-1。
for（i1=i。
i1i1++>//将后续式子前移两项
sz[i1]=sz[i1+2]。
i--。
}
for（i=0。
ii++>//处理蕴含。
if（sz[i]=='^'>
{
for（i1=0。
i1i1++>
{
if（sz[i-1]==ccu[i1]>//将变量赋值并给P1
p1=icu[i1]。
if（sz[i+1]==ccu[i1]>//将变量赋值并给P2
p2=icu[i1]。
}
for（i2=2。
i2i2++>
{
if（sz[i-1]==i2>//如果为前计算结果，将结果赋值并给P1
p1=dt[i2]。
if（sz[i+1]==i2>//如果为前计算结果，将结果赋值并给P2
p2=dt[i2]。
}
if（sz[i-1]==-2>//如果是前运算结果的0，则P1等于0
p1=0。
if（sz[i+1]==-2>//如果是前运算结果的0，则P2等于0
p2=0。
if（p1==-1>//如果是数字，直接给P1
p1=sz[i-1]。
if（p2==-1>//如果是数字，直接给P2
p2=sz[i+1]。
dt[j+2]=!
p1||p2。
//蕴含运算
sz[i-1]=j+2。
j++。
j4++。
p1=-1。
p2=-1。
for（i1=i。
i1i1++>//将后续式子前移两项
sz[i1]=sz[i1+2]。
i--。
}
for（i=0。
ii++>//处理等值。
if（sz[i]=='~'>
{
for（i1=0。
i1i1++>
{
if（sz[i-1]==ccu[i1]>//将变量赋值并给P1
p1=icu[i1]。
if（sz[i+1]==ccu[i1]>//将变量赋值并给P2
p2=icu[i1]。
}
for（i2=2。
i2i2++>
{
if（sz[i-1]==i2>//如果为前计算结果，将结果赋值并给P1
p1=dt[i2]。
if（sz[i+1]==i2>//如果为前计算结果，将结果赋值并给P2
p2=dt[i2]。
}
if（sz[i-1]==-2>//如果是前运算结果的0，则P1等于0
p1=0。
if（sz[i+1]==-2>//如果是前运算结果的0，则P2等于0
p2=0。
if（p1==-1>//如果是数字，直接给P1
p1=sz[i-1]。
升级会员 