和
while(i<na&&j<nb&&A[i]==B[j])
{i++;j++;}
前者是无论条件成立不成立i和j都是加1的;
后者只有当条件成立时i和j才是加1的。
请问这样理解对吗?
20 个解决方案
#1
你这个问题似乎已经问过了
有结贴吗?
这里
while(i<na&&j<nb&&A[i++]==B[j++]);
和
while(i<na&&j<nb&&A[i]==B[j])
{i++;j++;}
前者是只要i<na&&j<nb,都要检测A[i++]==B[j++]是否为真,也就是说i,j都会加一
而后者是只有当全部的3个条件都为真是,i,j才会加1
有结贴吗?
这里
while(i<na&&j<nb&&A[i++]==B[j++]);
和
while(i<na&&j<nb&&A[i]==B[j])
{i++;j++;}
前者是只要i<na&&j<nb,都要检测A[i++]==B[j++]是否为真,也就是说i,j都会加一
而后者是只有当全部的3个条件都为真是,i,j才会加1
#2
这两条语句没区别
#3
我想再确定一下。
不过
《哈哈
这个是
如果i<na&&i<nb&&A[i]==B[j]成立的话,就什么都不做
如果如果i<na&&i<nb&&A[i]==B[j]不成立的话,就
执行i++和j++.》
这可是你前一次给的回复啊。有点歧义。
这次可清楚多了。谢谢 kobefly(科比---开始学习c++!) 啦
不过
《哈哈
这个是
如果i<na&&i<nb&&A[i]==B[j]成立的话,就什么都不做
如果如果i<na&&i<nb&&A[i]==B[j]不成立的话,就
执行i++和j++.》
这可是你前一次给的回复啊。有点歧义。
这次可清楚多了。谢谢 kobefly(科比---开始学习c++!) 啦
#4
最显著的区别就是第2个while结束后i和j会比第一个各加一
#5
说反了,是第一个比第二个各多一
#6
当然有区别了
下面那个有语句啊
下面那个有语句啊
#7
第一句:i和j先加一,然后判断是否相等!
第二句:先判断i和j是否相等,再执行加一!
第二句:先判断i和j是否相等,再执行加一!
#8
不明白。。。。
#9
这种问题可以试一下不就清楚了
#10
我认为第一句的 A[i++]==B[j++] 判断的是A[i]==B[j]是否成立,判断完之后不管是不是成立i,j都会加1
而A[++i]==B[++j] 才是先+1再判断A B是否相等
而A[++i]==B[++j] 才是先+1再判断A B是否相等
#11
最好
while(i<na&&j<nb&&(A[i++]==B[j++]));
while(i<na&&j<nb&&(A[i++]==B[j++]));
#12
个人同意polymer(午夜幽铃) 的观点
这样的问题
好好看下谭浩强先生的《C语言程序设计》吧
这样的问题
好好看下谭浩强先生的《C语言程序设计》吧
#13
>> while(i<na&&j<nb&&A[i++]==B[j++]);
>> 和
>> while(i<na&&j<nb&&A[i]==B[j])
>> {i++;j++;}
>> 前者是无论条件成立不成立i和j都是加1的;
>> 后者只有当条件成立时i和j才是加1的。
>> 请问这样理解对吗?
对于后者的理解是对的,但是对于前者的说法不对。
对于前者while(i<na&&j<nb&&A[i++]==B[j++]);,正确的说法是:只有i<na且j<nb成立的时候才会对表达式A[i++]==B[j++]求值,i和j才有自加运算。也就是说i和j的自加运算是否执行取决于前两个条件i<na&&j<nb的结果。
而对于后者,只有三个条件全部满足i和j才进行自加运算。因此说这两个while是不同的。
这是&&运算符特殊的地方,需加以注意。
>> 和
>> while(i<na&&j<nb&&A[i]==B[j])
>> {i++;j++;}
>> 前者是无论条件成立不成立i和j都是加1的;
>> 后者只有当条件成立时i和j才是加1的。
>> 请问这样理解对吗?
对于后者的理解是对的,但是对于前者的说法不对。
对于前者while(i<na&&j<nb&&A[i++]==B[j++]);,正确的说法是:只有i<na且j<nb成立的时候才会对表达式A[i++]==B[j++]求值,i和j才有自加运算。也就是说i和j的自加运算是否执行取决于前两个条件i<na&&j<nb的结果。
而对于后者,只有三个条件全部满足i和j才进行自加运算。因此说这两个while是不同的。
这是&&运算符特殊的地方,需加以注意。
#14
同意楼上的,和2楼的!!!!!!
#15
我也同意whyglinux(山青水秀)的看法。不过我想问下i和j两个输出的最终结果是否一样阿?
#16
#include <iostream>
#include <stdlib.h>
main(){
int i,j,na,nb,A[3],B[3];
i=1;
j=1;
na=6;
nb=7;
A[3]=(1,2,3);
B[3]=(2,2,3);
while(i<na&&j<nb&&A[i++]==B[j++])
{
}
cout<<" the i is " <<i<<endl;
cout<<" the j is "<< j<<endl;
system("pause");
}
----------------------------
result:
the i is 2
the j is 2
请按任意键继续 . .
#include <stdlib.h>
main(){
int i,j,na,nb,A[3],B[3];
i=1;
j=1;
na=6;
nb=7;
A[3]=(1,2,3);
B[3]=(2,2,3);
while(i<na&&j<nb&&A[i++]==B[j++])
{
}
cout<<" the i is " <<i<<endl;
cout<<" the j is "<< j<<endl;
system("pause");
}
----------------------------
result:
the i is 2
the j is 2
请按任意键继续 . .
#17
相当基础的问题了,while循环语句是当型循环,只要()内的成立才执行子句,括号里的是&&运算就都得执行,第二个while的i,j的自增是在子句中进行的
如果循环条件都成立那么两个语句的都一样。
如果循环条件都成立那么两个语句的都一样。
#18
是不是跳出的时候,第二个语句会比第一个ij都大一?
#19
这两者是有所不同的
(1)while(i<na&&j<nb&&A[i++]==B[j++]);
不知大家有没有听说过‘短路’,当“i<na&&j<nb”返回值是"false"时,后面的表达式不会计算了,也就是说i++和j++不会计算,而当“i<na&&j<nb”返回值是"true"时,将首先比较A[i]是否等于B[j],不管是否相等i++和j++都将会在大括号之前计算。
(2)while(i<na&&j<nb&&A[i]==B[j]){i++;j++}
当“i<na&&j<nb”返回值是"false"时,后面的表达式不会计算了,这一点和前者相同,但是当“i<na&&j<nb”返回值是"true"时,将首先比较A[i]是否等于B[j],若相等则计算i++,j++;否则i++和j++将不会计算。
(1)while(i<na&&j<nb&&A[i++]==B[j++]);
不知大家有没有听说过‘短路’,当“i<na&&j<nb”返回值是"false"时,后面的表达式不会计算了,也就是说i++和j++不会计算,而当“i<na&&j<nb”返回值是"true"时,将首先比较A[i]是否等于B[j],不管是否相等i++和j++都将会在大括号之前计算。
(2)while(i<na&&j<nb&&A[i]==B[j]){i++;j++}
当“i<na&&j<nb”返回值是"false"时,后面的表达式不会计算了,这一点和前者相同,但是当“i<na&&j<nb”返回值是"true"时,将首先比较A[i]是否等于B[j],若相等则计算i++,j++;否则i++和j++将不会计算。
#20
要是i<na&&j<nb 的值是false 程序还会再往下走么?就是说 还会来进行自加和比较么?
ps:我怎么找不到发帖子的地方啊~~~~~
ps:我怎么找不到发帖子的地方啊~~~~~
#1
你这个问题似乎已经问过了
有结贴吗?
这里
while(i<na&&j<nb&&A[i++]==B[j++]);
和
while(i<na&&j<nb&&A[i]==B[j])
{i++;j++;}
前者是只要i<na&&j<nb,都要检测A[i++]==B[j++]是否为真,也就是说i,j都会加一
而后者是只有当全部的3个条件都为真是,i,j才会加1
有结贴吗?
这里
while(i<na&&j<nb&&A[i++]==B[j++]);
和
while(i<na&&j<nb&&A[i]==B[j])
{i++;j++;}
前者是只要i<na&&j<nb,都要检测A[i++]==B[j++]是否为真,也就是说i,j都会加一
而后者是只有当全部的3个条件都为真是,i,j才会加1
#2
这两条语句没区别
#3
我想再确定一下。
不过
《哈哈
这个是
如果i<na&&i<nb&&A[i]==B[j]成立的话,就什么都不做
如果如果i<na&&i<nb&&A[i]==B[j]不成立的话,就
执行i++和j++.》
这可是你前一次给的回复啊。有点歧义。
这次可清楚多了。谢谢 kobefly(科比---开始学习c++!) 啦
不过
《哈哈
这个是
如果i<na&&i<nb&&A[i]==B[j]成立的话,就什么都不做
如果如果i<na&&i<nb&&A[i]==B[j]不成立的话,就
执行i++和j++.》
这可是你前一次给的回复啊。有点歧义。
这次可清楚多了。谢谢 kobefly(科比---开始学习c++!) 啦
#4
最显著的区别就是第2个while结束后i和j会比第一个各加一
#5
说反了,是第一个比第二个各多一
#6
当然有区别了
下面那个有语句啊
下面那个有语句啊
#7
第一句:i和j先加一,然后判断是否相等!
第二句:先判断i和j是否相等,再执行加一!
第二句:先判断i和j是否相等,再执行加一!
#8
不明白。。。。
#9
这种问题可以试一下不就清楚了
#10
我认为第一句的 A[i++]==B[j++] 判断的是A[i]==B[j]是否成立,判断完之后不管是不是成立i,j都会加1
而A[++i]==B[++j] 才是先+1再判断A B是否相等
而A[++i]==B[++j] 才是先+1再判断A B是否相等
#11
最好
while(i<na&&j<nb&&(A[i++]==B[j++]));
while(i<na&&j<nb&&(A[i++]==B[j++]));
#12
个人同意polymer(午夜幽铃) 的观点
这样的问题
好好看下谭浩强先生的《C语言程序设计》吧
这样的问题
好好看下谭浩强先生的《C语言程序设计》吧
#13
>> while(i<na&&j<nb&&A[i++]==B[j++]);
>> 和
>> while(i<na&&j<nb&&A[i]==B[j])
>> {i++;j++;}
>> 前者是无论条件成立不成立i和j都是加1的;
>> 后者只有当条件成立时i和j才是加1的。
>> 请问这样理解对吗?
对于后者的理解是对的,但是对于前者的说法不对。
对于前者while(i<na&&j<nb&&A[i++]==B[j++]);,正确的说法是:只有i<na且j<nb成立的时候才会对表达式A[i++]==B[j++]求值,i和j才有自加运算。也就是说i和j的自加运算是否执行取决于前两个条件i<na&&j<nb的结果。
而对于后者,只有三个条件全部满足i和j才进行自加运算。因此说这两个while是不同的。
这是&&运算符特殊的地方,需加以注意。
>> 和
>> while(i<na&&j<nb&&A[i]==B[j])
>> {i++;j++;}
>> 前者是无论条件成立不成立i和j都是加1的;
>> 后者只有当条件成立时i和j才是加1的。
>> 请问这样理解对吗?
对于后者的理解是对的,但是对于前者的说法不对。
对于前者while(i<na&&j<nb&&A[i++]==B[j++]);,正确的说法是:只有i<na且j<nb成立的时候才会对表达式A[i++]==B[j++]求值,i和j才有自加运算。也就是说i和j的自加运算是否执行取决于前两个条件i<na&&j<nb的结果。
而对于后者,只有三个条件全部满足i和j才进行自加运算。因此说这两个while是不同的。
这是&&运算符特殊的地方,需加以注意。
#14
同意楼上的,和2楼的!!!!!!
#15
我也同意whyglinux(山青水秀)的看法。不过我想问下i和j两个输出的最终结果是否一样阿?
#16
#include <iostream>
#include <stdlib.h>
main(){
int i,j,na,nb,A[3],B[3];
i=1;
j=1;
na=6;
nb=7;
A[3]=(1,2,3);
B[3]=(2,2,3);
while(i<na&&j<nb&&A[i++]==B[j++])
{
}
cout<<" the i is " <<i<<endl;
cout<<" the j is "<< j<<endl;
system("pause");
}
----------------------------
result:
the i is 2
the j is 2
请按任意键继续 . .
#include <stdlib.h>
main(){
int i,j,na,nb,A[3],B[3];
i=1;
j=1;
na=6;
nb=7;
A[3]=(1,2,3);
B[3]=(2,2,3);
while(i<na&&j<nb&&A[i++]==B[j++])
{
}
cout<<" the i is " <<i<<endl;
cout<<" the j is "<< j<<endl;
system("pause");
}
----------------------------
result:
the i is 2
the j is 2
请按任意键继续 . .
#17
相当基础的问题了,while循环语句是当型循环,只要()内的成立才执行子句,括号里的是&&运算就都得执行,第二个while的i,j的自增是在子句中进行的
如果循环条件都成立那么两个语句的都一样。
如果循环条件都成立那么两个语句的都一样。
#18
是不是跳出的时候,第二个语句会比第一个ij都大一?
#19
这两者是有所不同的
(1)while(i<na&&j<nb&&A[i++]==B[j++]);
不知大家有没有听说过‘短路’,当“i<na&&j<nb”返回值是"false"时,后面的表达式不会计算了,也就是说i++和j++不会计算,而当“i<na&&j<nb”返回值是"true"时,将首先比较A[i]是否等于B[j],不管是否相等i++和j++都将会在大括号之前计算。
(2)while(i<na&&j<nb&&A[i]==B[j]){i++;j++}
当“i<na&&j<nb”返回值是"false"时,后面的表达式不会计算了,这一点和前者相同,但是当“i<na&&j<nb”返回值是"true"时,将首先比较A[i]是否等于B[j],若相等则计算i++,j++;否则i++和j++将不会计算。
(1)while(i<na&&j<nb&&A[i++]==B[j++]);
不知大家有没有听说过‘短路’,当“i<na&&j<nb”返回值是"false"时,后面的表达式不会计算了,也就是说i++和j++不会计算,而当“i<na&&j<nb”返回值是"true"时,将首先比较A[i]是否等于B[j],不管是否相等i++和j++都将会在大括号之前计算。
(2)while(i<na&&j<nb&&A[i]==B[j]){i++;j++}
当“i<na&&j<nb”返回值是"false"时,后面的表达式不会计算了,这一点和前者相同,但是当“i<na&&j<nb”返回值是"true"时,将首先比较A[i]是否等于B[j],若相等则计算i++,j++;否则i++和j++将不会计算。
#20
要是i<na&&j<nb 的值是false 程序还会再往下走么?就是说 还会来进行自加和比较么?
ps:我怎么找不到发帖子的地方啊~~~~~
ps:我怎么找不到发帖子的地方啊~~~~~