70,022
社区成员
发帖
与我相关
我的任务
分享C语言自加、自减问题
#include<stdio.h>
int main()
{
int x[5]={1,2,3,4,5},*p=x;
if((++p)==(++p))
printf("%d",*p);
else
printf("error");
getchar();
return 0;
}
和
#include<stdio.h>
int main()
{
int x[5]={1,2,3,4,5},*p=x;
if(*(++p)==*(++p))
printf("%d",*p);
else
printf("error");
getchar();
return 0;
}
为什么输出结果不一样
int main()
{
int x[5]={1,2,3,4,5},*p=x;
if((++p)==(++p))
printf("%d",*p);
else
printf("error");
getchar();
return 0;
}
和
#include<stdio.h>
int main()
{
int x[5]={1,2,3,4,5},*p=x;
if(*(++p)==*(++p))
printf("%d",*p);
else
printf("error");
getchar();
return 0;
}
为什么输出结果不一样
...全文
请发表友善的回复…
发表回复
艾薇儿More 2013-06-06
- 打赏
- 举报
不同的编译器不一样，就像
int i= 10；
i= i-- - --i *(i=-3)*i++ + ++i;(来自c和指针）。
但是像你这个还是比较容易解释的
lin5161678 2013-06-03
- 打赏
- 举报
优先级无能为力 加括号缘木求鱼
这段代码已经有加括号了 但是 错误还是错误
你这真够敷衍的
赵4老师 2013-06-03
- 打赏
- 举报
自己写代码搞不清楚算符优先级请多加括号。
看别人代码搞不清楚算符优先级能调试的话请单步调试对应汇编。
看别人代码搞不清楚算符优先级不能调试的话想办法照写一小段孤立的可调试的代码然后单步调试对应汇编。
看别人代码搞不清楚算符优先级不能调试的话且没有办法照写一小段孤立的可调试的代码然后单步调试对应汇编的话只能参考算符优先级表猜了（提醒：并不能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 |
//+------------------+-----------------------------------------+---------------+
Gsnsm 2013-06-03
- 打赏
- 举报
不要在一个表达式里对同一个变量进行多次自增或自减
wizard_tiger 2013-06-03
- 打赏
- 举报
这种自已都看不懂的代码还是少写的好，没什么意义。
小玲子 2013-06-03
- 打赏
- 举报
以前我也问过这样的问题，自加自减对不同编译器好像是不一样的，这种代码建议还是不要写
hugett 2013-06-03
- 打赏
- 举报
不要写这样的代码。。。
不过。。我在VS2010上跑了一下。。两个的结果是一样的。。
worldy 2013-06-01
- 打赏
- 举报
if(++p)==(++p)
这个应该不成立的
假设p开始时候为1，第一次++P后则为2，==的右边又++p，则p为3，2！=3所以应该是false
buyong 2013-06-01
- 打赏
- 举报
这种不好的用法，讨论没有意义。不同编译器结果都不同。
绯红女王 2013-06-01
- 打赏
- 举报
我机器上显示的是一样的，W7，VC++6.0
AnYidan 2013-06-01
- 打赏
- 举报
(++p)==(++p)
*(++p)==*(++p)
lz 自己写的还是借鉴来的 ？
xiao0915 2013-06-01
- 打赏
- 举报
看置顶的帖子. 正解~
iamnobody 2013-06-01
- 打赏
- 举报
看置顶的帖子.
winassembly 2013-06-01
- 打赏
- 举报
不会呀，同一种编译器的处理方式是一致的，只要你是用同一种编译器编译，然后运行，结果就是一样的。我在我的机器上用同一种编译器编译运行，得到的结果是一样的。
_Cogito_ 2013-06-01
- 打赏
- 举报
(++p)=(++p)是移动指针位置，修改p所指向的对象
*(++p)=*(++p)是在移动指针位置后修改数组的内容
两者没什么关系
羽飞 2013-06-01
- 打赏
- 举报
(++p)==(++p) 这个是对指针赋值
*(++p)==*(++p) 这个是对指针指向的值赋值修改
两个本来没有联系
