C语言中 加法运算和逻辑运算 哪个效率高

不明白楼上的啥意思。呵呵

加法的效率肯定是最快的。原因是处理器内部加逻辑单元，所以加法速度最快。

逻辑运算符，实质上也是进入到加逻辑单元进行运算，但是运算之前要把逻辑运算符转换为加运算符。所以效率低点。但是也很快。

在计算机中，一切运算都是通过转换到加运算符执行 *** 作的。

1加法交换律与加法结合律

加法交换律：

两个数相加，交换加数的位置，它们的和不变。即a+b=b+a

一般地，多个数相加，任意改变相加的次序，其和不变。

a+b+c+d=d+b+a+c

加法结合律：

几个数相加，先把前两个数相加，再加上第三个数；或者，先把后两个数相加，再与第一个数相加，它们的和不变。即：a+b+c = (a+b)+c = a+(b+c)，

2速算与巧算中常用的三大基本思想

1凑整 （目标：整十 整百 整千）

2分拆（分拆后能够凑成 整十 整百 整千）

3组合(合理分组再组合 )

3常见方法

凑整法

两个数相加，若能恰好凑成整十、整百、整千、整万…，就把其中的一个数叫做另一个数的"补数"，利用"补数"巧算加法，通常称为"凑整法"

如：1+9=10，3+7=10，2+8=10，4+6=10，5+5=10。

又如：11+89=100，33＋67=100，22+78=100，44+56=100，55+45=100，

在上面算式中，1叫9的"补数"；89叫11的"补数"，11也叫89的"补数"。也就是说两个数互为"补数"。

对于一个较大的数，如何能很快地算出它的"补数"来呢？一般来说，可以这样"凑"数：从最高位凑起，使各位数字相加得9，到最后个位数字相加得10。

如： 87655→12345， 46802→53198，87362→12638，…

下面讲利用"补数"巧算加法，通常称为"凑整法"。

巧算下面各题：

①36+87+64

②99+136＋101

③1361＋972＋639＋28

解：

①式=（36＋64）＋87=100＋87=187

②式=（99＋101）＋136=200+136=336

③式=（1361＋639）＋（972＋28）=2000+1000=3000

组合凑整法

（1）在加、减法混合运算中，去括号时：如果括号前面是“＋”号，那么去掉括号后，括号内的数的运算符号不变；如果括号前面是“-”号，那么去掉括号后，括号内的数的运算符号“＋”变为“-”，“-”变为“＋”

（2）在加、减法混合运算中，添括号时：如果添加的括号前面是“＋”号，那么括号内的数的原运算符号不变；如果添加的括号前面是“-”号，那么括号内的数的原运算符号“＋”变为“－”，“-”变为“＋”。

（3）利用“补数”把接近整十、整百、整千…的数先变整，再运算（注意把多加的数再减去，把多减的数再加上）。

基准法

在减法运算过程中利用补数原理，先将几个减数凑整，再进行减法运算。在使用基准数法时，应选取与各数的差较小的数作为基准数，这样才容易计算累计差。同时考虑到基准数与加数个数的乘法能够方便地计算出来，所以基准数应尽量选取整十、整百的数。

计算 78+76＋83＋82+77＋80＋79＋85＝640

#include <iostream>

using namespace std;

int main()

{

double num1,num2;

cout<<"输入两个数：";

cin>>num1>>num2;

cout<<"运算加法的结果："<<num1+num2<<endl; 

cout<<"运算减法的结果："<<num1-num2<<endl;

cout<<"运算乘法的结果："<<num1num2<<endl; 

cout<<"运算除法的结果："<<num1/num2<<endl;  

return 0; 

 } 

可以做一个计算机界面！

楼主，你用是什么的汇编啊。是8088/8086,还是单片机的，是什么公司的产品，什么型号的，它们都是有一些差异的。

我在这就说一下思路吧。用汇编做加减法比较容易，带进位不带进位的都可以，做乘除是比较难的，一般是不用它做的，必须时也最好转换成加减，这样在实现的时候才会方便。

我再说点MC51的汇编语言，也许你能用上。(都是一些语法)

带进位加法：addc a,#data ;(a)+#data+(c)--> (a)

addc a,data ;(a)+(data)+(c)-->(a)

addc a,@r;(a)+((r))+(c)-->(a)

带进位的减法：subb a,#data

subb a,data

subb a,@r1

乘法：mul a b;(a)(b)

除法：div a b;(a)/(b)

#include<stdioh>

struct complex add(struct complex  c1,struct complex c2);

struct complex amass(struct complex  c1,struct complex c2);

struct complex

{

int real;

int image;

};

void main()

{

struct complex a,b;

while(scanf("%d%d%d%d",&areal,&aimage,&breal,&bimage)!=EOF)

{

add(a,b);

amass(a,b);

}

}

struct complex add(struct complex  c1,struct complex c2)

{

printf("%d+(%di)\n",c1real+c2real,c1image+c2image);

return c1;

}

struct complex amass(struct complex  c1,struct complex c2)

{

printf("%d+(%di)\n",(c1realc2real-c1imagec2image),(c1realc2image+c2realc1image));

return c1;

}

扩展资料：

main（）函数用法：

大多数UNIX系统对main函数提供了三个参数，原型如下：

intmain（intargc，char＊argv［］，char＊env［］）；

其中第三个参数是环境表地址。

ANSIC规定main函数只有两个参数，而且第三个参数与全局变量environ相比也没有带来更多益处，所以POSIX．1也规定应使用environ而不使用第三个参数。

通常用getenv和putenv函数来存取特定的环境变量，而不是用environ变量。

main函数的原型多是下面这种形式：

intmain（intargc，char＊argv［］），参数argc代表了输入参数的个数，char＊argv［］表示传入的参数的字符串，是一个字符串数组。

例如在linux平台下编写一个小程序：

int main（intargc，char＊argv［］）

｛

int i；

printf（＂argc：％d＼n＂，argc）；

for（i＝0；i＜argc；i＋＋）

｛

printf（＂argv［％d］：％s＼n＂，i，argv［i］）；

｝

exit（0）；

｝

用gcc编译后形成一个a．out的可执行的文件，运行a．out，其结果是：

argc＝1，argv［0］＝”a．out”

运行的程序的文件名，也占用一个参数位置，也就是说argv数组中的第一个单元指向的字符串总是可执行程序的名字，以后的单元指向的字符串依次是程序调用时的参数。这个赋值过程是 *** 作系统完成的，只需要拿来用就可以了。

在命令行参数的提交中，系统会自动给指针数组后加上一个NULL，所以for（i＝0；i＜argc；i＋＋）这句也可以换成while（＊argv！＝NULL）

int main（intargc）省略其它参数的定义也是可以的，这样运行时候argc就直接返回参数个数，而不返回其它。

运行命令行参数带有char＊argv［］的时候，如果输入参数带有空格，应该用双引号括起来。

宏指令G65可以实现丰富的宏功能，包括算术运算、逻辑运算等处理功能。

一般形式： G65 Hm P#i Q#j R#k

式中：

m--宏程序功能，数值范围01～99；

#i--运算结果存放处的变量名；

#j--被 *** 作的第一个变量，也可以是一个常数；

#k--被 *** 作的第二个变量，也可以是一个常数。

例如，当程序功能为加法运算时：

程序　P#100 Q#101 R#102　含义为#100＝#101＋#102

程序　P#100 Q-#101 R#102　含义为#100＝-#101＋#102

程序　P#100 Q#101 R15　含义为#100＝#101＋15

1、宏功能指令

（1）算术运算指令（表44）

表44 算术运算指令

G码 H码 功 能 定 义

G65 H01 定义，替换 # i＝# j

G65 H02 加 # i＝# j＋# k

G65 H03 减 # i＝# j-# k

G65 H04 乘 # i＝# j × # k

G65 H05 除 # i＝# j/# k

G65 H21 平方根 # i＝√# j

G65 H22 绝对值 # i＝|# j|

G65 H23 求余 # i＝# j-trunc﹙# j/# k﹚· # k

Trunc；丢弃小于1的分数部分

G65 H24 BCD码→二进制码 # i＝BIN﹙# j﹚

G65 H25 二进制码→BCD码 # i＝BCD﹙# j﹚

G65 H26 复合乘/除 # i＝﹙# i × # j﹚÷# k

G65 H27 复合平方根1 # i＝√# j2＋# k2

G65 H28 复合平方根2 # i＝√# j2-# k2

1）变量的定义和替换 #i＝#j

编程格式 G65 H01 P#i Q#j

例 G65 H01 P#101 Q1005； (#101＝1005)

G65 H01 P#101 Q-#112；(#101＝-#112)

2）加法 #i＝#j＋#k

编程格式 G65 H02 P#i Q#j R#k

例 G65 H02 P#101 Q#102 R#103；(#101＝#102＋#103)

3）减法 #i＝#j-#k

编程格式 G65 H03 P#i Q#j R#k

例 G65 H03 P#101 Q#102 R#103；(#101＝#102-#103)

4）乘法 #i＝#j×#k

编程格式 G65 H04 P#i Q#j R#k

例 G65 H04 P#101 Q#102 R#103；(#101＝#102×#103)

5）除法 #i＝#j / #k

编程格式 G65 H05 P#i Q#j R#k

例 G65 H05 P#101 Q#102 R#103；(#101＝#102/#103)

6）平方根 #i＝

编程格式 G65 H21 P#i Q#j

例 G65 H21 P#101 Q#102；(#101＝ )

7）绝对值 #i＝│#j│

编程格式 G65 H22 P#i Q#j

例 G65 H22 P#101 Q#102；(#101＝│#102│)

8）复合平方根1 #i＝

编程格式 G65 H27 P#i Q#j R#k

例 G65 H27 P#101 Q#102 R#103；(#101=

9）复合平方根2 #i＝

编程格式 G65 H28 P#i Q#j R#k

例 G65 H28 P#101 Q#102 R#103(#101＝

（2）逻辑运算指令（表45）

表45 逻辑运算指令

G码 H码 功 能 定 义

G65 H11 逻辑“或” # i＝# j · OR · # k

G65 H12 逻辑“与” # i＝# j · AND · # k

G65 H13 异或 # i＝# j · XOR · # k

1）逻辑或 #i＝#j OR #k

编程格式 G65 H11 P#i Q#j R#k

例 G65 H11 P#101 Q#102 R#103；(#101＝#102 OR #103)

2）逻辑与 #i＝#j AND #k

编程格式 G65 H12 P#i Q#j R#k

例 G65 H12 P#101 Q#102 R#103；(#101＝#102 AND #103)

（3）三角函数指令（表46）

表46 三角函数指令

G码 H码 功 能 定 义

G65 H31 正弦 # i＝# j · SIN ﹙# k﹚

G65 H32 余弦 # i＝# j · COS ﹙# k﹚

G65 H33 正切 # i＝# j · TAN﹙# k﹚

G65 H34 反正切 # i＝ATAN﹙# j/# k﹚

1）正弦函数 #i＝#j×SIN(#k)

编程格式 G65 H31 P#i Q#j R#k (单位：度)

例 G65 H31 P#101 Q#102 R#103；(#101＝#102×SIN(#103))

2）余弦函数 #i＝#j×COS(#k)

编程格式G65 H32 P#i Q#j R#k (单位：度)

例 G65 H32 P#101 Q#102 R#103；(#101＝#102×COS(#103))

3）正切函数 #i＝#j×TAN#k

编程格式G65 H33 P#i Q#j R#k (单位：度)

例 G65 H33 P#101 Q#102 R#103；(#101＝#102×TAN(#103))

4）反正切 #i＝ATAN(#j/#k)

编程格式G65 H34 P#i Q#j R#k (单位：度，0o≤ #j ≤360o)

例 G65 H34 P#101 Q#102 R#103；(#101＝ATAN(#102/#103))

（4）控制类指令（表47）

表47 控制类指令

G码 H码 功 能 定 义

G65 H80 无条件转移 GO TO n

G65 H81 条件转移1 IF # j＝# k，GOTOn

G65 H82 条件转移2 IF # j≠# k，GOTOn

G65 H83 条件转移3 IF # j＞# k，GOTOn

G65 H84 条件转移4 IF # j＜# k，GOTOn

G65 H85 条件转移5 IF # j≥# k，GOTOn

G65 H86 条件转移6 IF # j≤# k，GOTOn

G65 H99 产生PS报警 PS报警号500＋n出现

1）无条件转移

编程格式G65 H80 Pn (n为程序段号)

例G65 H80 P120；(转移到N120)

2）条件转移1 #j EQ #k(＝)

编程格式G65 H81 Pn Q#j R#k (n为程序段号)

例 G65 H81 P1000 Q#101 R#102

当#101＝#102，转移到N1000程序段；若#101≠ #102，执行下一程序段。

3）条件转移2 #j NE #k（≠）

编程格式G65 H82 Pn Q#j R#k (n为程序段号)

例 G65 H82 P1000 Q#101 R#102

当#101≠ #102，转移到N1000程序段；若#101＝#102，执行下一程序段。

4）条件转移3 #j GT #k (> )

编程格式G65 H83 Pn Q#j R#k (n为程序段号)

例 G65 H83 P1000 Q#101 R#102

当#101 > #102，转移到N1000程序段；若#101 ≤#102，执行下一程序段。

5）条件转移4 #j LT #k（<）

编程格式 G65 H84 Pn Q#j R#k (n为程序段号)

例 G65 H84 P1000 Q#101 R#102

当#101 < #102，转移到N1000；若#101≥ #102，执行下一程序段。

6）条件转移5 #j GE #k(≥)

编程格式 G65 H85 Pn Q#j R#k (n为程序段号)

例 G65 H85 P1000 Q#101 R#102

当#101≥ #102，转移到N1000；若#101<#102，执行下一程序段。

7）条件转移6 #j LE #k（≤）

编程格式 G65 H86 Pn Q#j Q#k (n为程序段号)

例 G65 H86 P1000 Q#101 R#102

当#101≤#102，转移到N1000；若#101>#102，执行下一程序段。

2、使用注意

为保证宏程序的正常运行，在使用用户宏程序的过程中，应注意以下几点；

（1）由G65规定的H码不影响偏移量的任何选择；

（2）如果用于各算术运算的Q或R未被指定，则作为0处理；

（3）在分支转移目标地址中，如果序号为正值，则检索过程是先向大程序号查找，如果序号为负值，则检索过程是先向小程序号查找。

（4）转移目标序号可以是变量。[em24][em27][em24]鐧惧害鍦板浘

这是关于C语言语法的一个问题,亦既预算符号的优先级;因为(++i)中的"++"符号位于变量的左边,他的优先级高于加法运算符号,因此这个运算式相当于i变量先执行三次自加,然后再执行算式中的加法运算;而i的初始值是3,自加了三次就等于6,而后三个6相加也就等于18!

以前听老师讲过着还与语言设置有关,具体请查阅资料

为什么算数纸牌游戏是计算24点而不是别的数？这其实是一个有意思的问题。

最简单的答复：因为24约数多啊！稍微认真点的回答：因为24有8个正约数，1、2、3、4、6、8、12、24，是一个超级合数，容易通过乘法来得到它，而且24本身也不太大，用4张扑克牌（点数1~10或1~13（J、Q、K分别代表11、12、13）），也比较容易通过加法来得到24，总之，通过四则运算算得24的方案数较多，所以随意抽取4张牌，有解的可能性较大，游戏也比较容易顺畅地进行。然而，这样的回答能令人满意吗？我认为不能。“可能性较大”是什么意思？有多大？和别的数比呢？——Talk is cheap, show me your data要算概率，首先计算4张牌可能出现的组合：如果4个数的范围都是1~10，那么去除重复的情况，不同的组合数为C{10+4-1}^{4}=\frac{13!}{4!\times 9!}=715种。如果4个数的范围都是1~13，那么去除重复的情况，不同的组合数为C{13+4-1}^{4}=\frac{16!}{4!\times 12!}=1820种。当然，由于扑克牌张数的特殊性，每种情况出现的概率实际上并不相等，甚至相差很大（比如实际上出现[3,4,5,6]的可能性是[6,6,6,6]的可能性的4^{4}=256倍），不过为了简化问题，只考虑哪些情况是有解的，并用有解的组合数/总组合数来计算有解的概率。正巧我最近刚开始自学Java，于是顺手编了一个算24的小程序，来计算所有数字组合的24点，写好代码，剩下的就交给计算机了！

嗯，结果出来了：

对于4个数均为1~10的715种情况，有566种有解，概率为7916%；对于4个数均为1~13的1820种情况，有1362种有解，概率为7483%。也就是说，如果我们只用数字牌，大约4/5的情况是能算出24点的，如果加上人头牌，这个概率大约是3/4。因此，玩24点游戏，总体来说还是比较顺畅的。当然，问题还远没有结束。对别的数，这个概率是多少呢？于是改一下程序，看看同样的组合，计算1~100的正整数，能算的概率是多少。

结果：1）四张扑克牌均为1~10时，结果如下图所示：横坐标为要计算的数，左边的纵坐标为有解的组合数，而右边纵坐标代表的是有解的概率。

是不是很出人意料！有最多解的计算值并不是24点！而是——2点。4个1~10的数计算2，有解的组合数为709组，有解概率高达9916%24呢？正如红圈所示，虽然有解率很高（明显高于23和25），但也并不是鹤立鸡群！你看，18和20有解的概率就比它高！2）四张扑克牌均为1~13时，结果如下图所示。

有解概率上，依然是2遥遥领先！因此，我的回答是：我们算24点，其实并不仅仅因为24点的有解概率大（虽然24的有解概率确实也不小，所有大于24的数有解概率都比24点小），如果只是为了有解概率大，那么我们应该计算2、3、1、4等小自然数。我们之所以会去算24，乃是因为它在有解概率较大的情况下，比那些小自然数有了更多的变化性（比如38，46，18+6，14+10……），因此计算起来更具有技巧些，因此对思维的训练也更有帮助。其实呢，24点，如果算厌倦了，也可以算算20点、36点等等，它们的有解概率也是很大的哟！另外，对于计算高手而言，算24点似乎简单了些，因为总共就715种或1820种变化，难题也就诸如[1,5,5,5]、[1,3,4,6]、[1,4,5,6]、[2,7,7,10]、[3,3,7,7]、[3,3,8,8]、[4,4,7,7]等寥寥几个，很容易就会厌倦的。

以上就是关于C语言中 加法运算和逻辑运算 哪个效率高全部的内容，包括:C语言中 加法运算和逻辑运算 哪个效率高、加减巧算速算方法、求用c++做一能加减乘除运算的计算器，要详细代码等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！