关于++,*,=的执行顺序若干问题

tankey0909 2013-02-26 10:43:27
1) if ((__res = *cs - *ct++) != 0 )
请问++是在 (__res = *cs - *ct)!=0后执行的吗?为什么,不是说在括号里的先执行吗,为何++不执 行?


2)if (*s1++ == '\0')
return (0);

++ 是在何时执行?

3) while((*s1++ = *s2++)!= '\0');

这个执行的顺序是什么?
*s1 = *s2
*s2++;*s1++ 是吗?是否到*s1 = '\0'还需要++?


还有大家能推荐些相关文章或试题吗?我这里太不熟悉了


...全文
293 23 打赏 收藏 转发到动态 举报
写回复
用AI写文章
23 条回复
切换为时间正序
请发表友善的回复…
发表回复
赵4老师 2013-02-27
  • 打赏
  • 举报
回复
说是一物即不中。
nadleeh 2013-02-27
  • 打赏
  • 举报
回复
[quote=引用 20 楼 lin5161678 的回复:] 引用 17 楼 nadleeh123 的回复:引用 14 楼 lin5161678 的回复:引用 9 楼 nadleeh123 的回复:*和++的问题 **(c++)和**c++ 的确一样,我到不会认为优先就先求值,例如**(c++)我不会认为c++会先执行.括号的优先级是相对的,不是绝对的.
lin5161678 2013-02-27
  • 打赏
  • 举报
回复
引用 17 楼 nadleeh123 的回复:
引用 14 楼 lin5161678 的回复:引用 9 楼 nadleeh123 的回复:*和++的问题依编译器,编程环境的不同可能会产生不同的结果,比如**c++这种玩意儿不用括号是很危险的。最好的方法就是*和++之间按照你想要的结果用括号小心括起来,扯那么多废物一样的代码干嘛。工作中谁这么写谁倒霉。不会有你说的 编程环境的不同可能会产生不同的结果 这几行代码 虽然不好……
**c++ 和 *(*c)++当然不一样 不用内核编程了 任何c编程 这两个表达式都不会一样 汗 你有没有看清楚我说的是什么 我说 **c++**(c++)是一样的 不管有没有加括号 第3,这些写法在某些3方平台和其他环境的确不可预知,但是我加了括号就绝对可预知.括号优先级是很高的. 你的第三点有误 这些写法在什么平台什么环境下的c语言都是可以预知 而加括号 面对 真正的 在某些3方平台和其他环境的确不可预知 这样的情况 依旧是不可预知的 加括号无效 我估计你对优先级的作用有误解 你是不是认为优先级高的子表达式会先求值??
Stinson_Zhao 2013-02-27
  • 打赏
  • 举报
回复
1、if括号里的是一个完整表达式(full expression),自增在计算完该完整表达式后进行 2、同理 3、先*s1 = *s2,再与‘\0’比较得出表达式的值,最后再*s2++;*s1++(至于这两个中哪个先是不确定的) 另:1、参加c primer plus运算符表达式那章 2、这样写虽然看似精简了代码,但是可读性下降了,自己衡量就好
nadleeh 2013-02-27
  • 打赏
  • 举报
回复
引用 14 楼 lin5161678 的回复:
引用 9 楼 nadleeh123 的回复:*和++的问题依编译器,编程环境的不同可能会产生不同的结果,比如**c++这种玩意儿不用括号是很危险的。最好的方法就是*和++之间按照你想要的结果用括号小心括起来,扯那么多废物一样的代码干嘛。工作中谁这么写谁倒霉。不会有你说的 编程环境的不同可能会产生不同的结果 这几行代码 虽然不好看 但是都是符合标准的做法 **c++ 就……
这些的确是标准c的格式,但是工作中不会写这样的,不符合代码良好阅读性这一条,第二这种问题的本质就是优先级和善用括号的问题,第3,这些写法在某些3方平台和其他环境的确不可预知,但是我加了括号就绝对可预知.括号优先级是很高的.
nadleeh 2013-02-27
  • 打赏
  • 举报
回复
引用 14 楼 lin5161678 的回复:
引用 9 楼 nadleeh123 的回复:*和++的问题依编译器,编程环境的不同可能会产生不同的结果,比如**c++这种玩意儿不用括号是很危险的。最好的方法就是*和++之间按照你想要的结果用括号小心括起来,扯那么多废物一样的代码干嘛。工作中谁这么写谁倒霉。不会有你说的 编程环境的不同可能会产生不同的结果 这几行代码 虽然不好看 但是都是符合标准的做法 **c++ 就……
内核编程**c++ 和 *(*c)++ 就不一样.不信你试,没依据我会乱说么-.-
lm_whales 2013-02-27
  • 打赏
  • 举报
回复
1) if ((__res = *cs - *ct++) != 0 ) 请问++是在 (__res = *cs - *ct)!=0后执行的吗?为什么,不是说在括号里的先执行吗,为何++不执 行? ++可以在任何地方执行,重要的是什么时候使用ct的值,在这里在++执行前,先使用ct的值 就是说 比如ct=3 在这里使用3 而不是ct++执行后的值ct =4; 另外括号里的先执行的意思是比外面先执行 (__res = *cs - *ct++)括号里的 =, *cs ,- *ct,++ 比括号外!= 先执行 注意是比相邻的运算符先执行! 比如 a= 5*(6+3)*5+6-3/2 ;6+3 比 5*6 先执行于是 成了5*9*5了 6+3 和3/2就不一定谁先执行了! 2)if (*s1++ == '\0') return (0); ++ 是在何时执行? 假设 a[]="3456"; s1=a; *s1 先执行,*s1=3 ;*s1++ 的值是 '3' 然后s1++(s1=a+1) 然后;*s1++ == '\0' 由于 ;*s1++ 的值是 '3' 于是 '3'和'\0' 比较结果为假;*s1++ == '\0'为假 这种情况下, 如果是在循环中,则下一轮循环,可以看到++的结果。 如果下面还有语句,下面的语句可以见到++的结果。 return(0) 不执行 如果s1=a+5; *s1++ == '\0' 为真 return(0) 执行 !!! 就是说++总是执行的,只是后缀++先用值,后++ 接着return 后就没有什么用了 3)while((*s1++ = *s2++)!= '\0'); 这个执行的顺序是什么? *s1 = *s2 *s2++;*s1++ 是吗?是否到*s1 = '\0'还需要++? 这个执行的顺序是什么? 执行的顺序是 *s1和 *s2 然后 执行 *s1++ = *s2++ 也就是执行 *s1=*s2了 表达式*s1++ = *s2++ 的是 *s1= *s2 的值,是自增前的*s2 接着执行s1++;s2++ 指针自增 接着执行比较(*s++ = *s2++)!= '\0' 表达式(*s++ = *s2++)的值是自增前的*s2 所以先赋值,接着指针自增,然后后比较,于是结束符也复制过来了! 到*s1 = '\0'还需要++!! 注意 *s1++ 自增的是指针 (*s1)++ 自增的的是指针所指的值! s1++;s2++;这两个自增并没有规定次序,而且规定了,也没有什么用处!!
nadleeh 2013-02-26
  • 打赏
  • 举报
回复
引用 楼主 tankey0909 的回复:
1) if ((__res = *cs - *ct++) != 0 ) 请问++是在 (__res = *cs - *ct)!=0后执行的吗?为什么,不是说在括号里的先执行吗,为何++不执 行? 2)if (*s1++ == '\0') return (0); ++ 是在何时执行? 3) while((*s1……
谭大爷的书吧? *和++的问题依编译器,编程环境的不同可能会产生不同的结果,比如**c++这种玩意儿不用括号是很危险的。最好的方法就是*和++之间按照你想要的结果用括号小心括起来,扯那么多废物一样的代码干嘛。工作中谁这么写谁倒霉。
linzhengqun 2013-02-26
  • 打赏
  • 举报
回复
楼上的回贴都自成体系了,请问你是不是有一个答题数据库呀,遇到类似的就一搜一贴就完了,这分拿得舒服,难怪这么多星。 但这种空洞的说教有什么意义呢?
赵4老师 2013-02-26
  • 打赏
  • 举报
回复
不要迷信书、考题、老师、回帖; 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实!
赵4老师 2013-02-26
  • 打赏
  • 举报
回复
自己写代码搞不清楚算符优先级请多加括号。 看别人代码搞不清楚算符优先级能调试的话请单步调试对应汇编。 看别人代码搞不清楚算符优先级不能调试的话想办法照写一小段孤立的可调试的代码然后单步调试对应汇编。 看别人代码搞不清楚算符优先级不能调试的话且没有办法照写一小段孤立的可调试的代码然后单步调试对应汇编的话只能参考下面的算符优先级表猜了(提醒:并不能100%猜对)。
//C++ Operators
//  Operators specify an evaluation to be performed on one of the following:
//    One operand (unary operator)
//    Two operands (binary operator)
//    Three operands (ternary operator)
//  The C++ language includes all C operators and adds several new operators.
//  Table 1.1 lists the operators available in Microsoft C++.
//  Operators follow a strict precedence which defines the evaluation order of
//expressions containing these operators.  Operators associate with either the
//expression on their left or the expression on their right;    this is called
//“associativity.” Operators in the same group have equal precedence and are
//evaluated left to right in an expression unless explicitly forced by a pair of
//parentheses, ( ).
//  Table 1.1 shows the precedence and associativity of C++ operators
//  (from highest to lowest precedence).
//
//Table 1.1   C++ Operator Precedence and Associativity
// The highest precedence level is at the top of the table.
//+------------------+-----------------------------------------+---------------+
//| Operator         | Name or Meaning                         | Associativity |
//+------------------+-----------------------------------------+---------------+
//| ::               | Scope resolution                        | None          |
//| ::               | Global                                  | None          |
//| [ ]              | Array subscript                         | Left to right |
//| ( )              | Function call                           | Left to right |
//| ( )              | Conversion                              | None          |
//| .                | Member selection (object)               | Left to right |
//| ->               | Member selection (pointer)              | Left to right |
//| ++               | Postfix increment                       | None          |
//| --               | Postfix decrement                       | None          |
//| new              | Allocate object                         | None          |
//| delete           | Deallocate object                       | None          |
//| delete[ ]        | Deallocate object                       | None          |
//| ++               | Prefix increment                        | None          |
//| --               | Prefix decrement                        | None          |
//| *                | Dereference                             | None          |
//| &                | Address-of                              | None          |
//| +                | Unary plus                              | None          |
//| -                | Arithmetic negation (unary)             | None          |
//| !                | Logical NOT                             | None          |
//| ~                | Bitwise complement                      | None          |
//| sizeof           | Size of object                          | None          |
//| sizeof ( )       | Size of type                            | None          |
//| typeid( )        | type name                               | None          |
//| (type)           | Type cast (conversion)                  | Right to left |
//| const_cast       | Type cast (conversion)                  | None          |
//| dynamic_cast     | Type cast (conversion)                  | None          |
//| reinterpret_cast | Type cast (conversion)                  | None          |
//| static_cast      | Type cast (conversion)                  | None          |
//| .*               | Apply pointer to class member (objects) | Left to right |
//| ->*              | Dereference pointer to class member     | Left to right |
//| *                | Multiplication                          | Left to right |
//| /                | Division                                | Left to right |
//| %                | Remainder (modulus)                     | Left to right |
//| +                | Addition                                | Left to right |
//| -                | Subtraction                             | Left to right |
//| <<               | Left shift                              | Left to right |
//| >>               | Right shift                             | Left to right |
//| <                | Less than                               | Left to right |
//| >                | Greater than                            | Left to right |
//| <=               | Less than or equal to                   | Left to right |
//| >=               | Greater than or equal to                | Left to right |
//| ==               | Equality                                | Left to right |
//| !=               | Inequality                              | Left to right |
//| &                | Bitwise AND                             | Left to right |
//| ^                | Bitwise exclusive OR                    | Left to right |
//| |                | Bitwise OR                              | Left to right |
//| &&               | Logical AND                             | Left to right |
//| ||               | Logical OR                              | Left to right |
//| e1?e2:e3         | Conditional                             | Right to left |
//| =                | Assignment                              | Right to left |
//| *=               | Multiplication assignment               | Right to left |
//| /=               | Division assignment                     | Right to left |
//| %=               | Modulus assignment                      | Right to left |
//| +=               | Addition assignment                     | Right to left |
//| -=               | Subtraction assignment                  | Right to left |
//| <<=              | Left-shift assignment                   | Right to left |
//| >>=              | Right-shift assignment                  | Right to left |
//| &=               | Bitwise AND assignment                  | Right to left |
//| |=               | Bitwise inclusive OR assignment         | Right to left |
//| ^=               | Bitwise exclusive OR assignment         | Right to left |
//| ,                | Comma                                   | Left to right |
//+------------------+-----------------------------------------+---------------+
luciferisnotsatan 2013-02-26
  • 打赏
  • 举报
回复
lz先说下 前++,后++ 分别是什么效果。 我估计lz没搞清这两个是什么效果。另外,也没弄清 *ct++ ct是结合++,还是结合*
starytx 2013-02-26
  • 打赏
  • 举报
回复
优先级问题,看看优先级列表就知道了。还可以看看表达式求值方面的东西。总之不要写那种难以理解,阅读,和依赖编译器行为的代码。
Franklin 2013-02-26
  • 打赏
  • 举报
回复
写个测试试试看。。。
tankey0909 2013-02-26
  • 打赏
  • 举报
回复
引用 1 楼 akirya 的回复:
俺表示看不懂,也不会这么写代码。 ++ --的都是单独写一行的。
源代码上面都是这么写的,得读懂啊
  • 打赏
  • 举报
回复
俺表示看不懂,也不会这么写代码。 ++ --的都是单独写一行的。
AnYidan 2013-02-26
  • 打赏
  • 举报
回复
[置顶] C,C++表达式求值顺序 裘老的解释。 [推荐] [C/C++ C++ 语言]
iamnobody 2013-02-26
  • 打赏
  • 举报
回复
看顶置的帖子. 或权威的书.不要看国内教材入门.
lin5161678 2013-02-26
  • 打赏
  • 举报
回复
引用 9 楼 nadleeh123 的回复:
*和++的问题依编译器,编程环境的不同可能会产生不同的结果,比如**c++这种玩意儿不用括号是很危险的。最好的方法就是*和++之间按照你想要的结果用括号小心括起来,扯那么多废物一样的代码干嘛。工作中谁这么写谁倒霉。
不会有你说的 编程环境的不同可能会产生不同的结果 这几行代码 虽然不好看 但是都是符合标准的做法 **c++ 就是 **(c++)没什么危险不危险的 用括号小心括起来 只是好看而已 真面对编程环境的不同可能会产生不同的结果的情况 一点用都没有
iEverX 2013-02-26
  • 打赏
  • 举报
回复
另外,这些代码都是符合C标准的,不同的编译器对于这这几个代码的行为是相同的。。
加载更多回复(3)

69,336

社区成员

发帖
与我相关
我的任务
社区描述
C语言相关问题讨论
社区管理员
  • C语言
  • 花神庙码农
  • 架构师李肯
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧