工具检测代码报错不知何意

[1az98你好]

In "this->m_MessageId = ++this->m_MessageId % 255", "this->m_MessageId" is written in "this->m_MessageId" (the assignment left-hand side) and written in "++this->m_MessageId % 255" but the order in which the side effects take place is undefined because there is no intervening sequence point.
m_MessageId = ((++m_MessageId) % 0xff);


这是用工具对代码检测时工具报的错误信息


不太理解这个错的意思是什么(不是英文意思不懂..)


求大神解答

[橡木疙瘩]

this->m_MessageId = ++this->m_MessageId % 255； this->m_MessageId在一个表达式语句中同时被赋值操作符和++操作符修改，两个修改顺序不同会得到不同的结果，因此这个表达式可能会因为使用的编译器不同而导致不同的结果。

[1az98你好]

引用 1 楼 u010936098 的回复:

this->m_MessageId = ++this->m_MessageId % 255； this->m_MessageId在一个表达式语句中同时被赋值操作符和++操作符修改，两个修改顺序不同会得到不同的结果，因此这个表达式可能会因为使用的编译器不同而导致不同的结果。

赋值操作的优先级不是最低的吗？ 这样不能保证 一定是 先++ 后赋值么？

[赵4老师]

自己写代码搞不清楚算符优先级请多加括号。 看别人代码搞不清楚算符优先级能调试的话请单步调试对应汇编。 看别人代码搞不清楚算符优先级不能调试的话想办法照写一小段孤立的可调试的代码然后单步调试对应汇编。 看别人代码搞不清楚算符优先级不能调试的话且没有办法照写一小段孤立的可调试的代码然后单步调试对应汇编的话只能参考算符优先级表猜了（提醒：并不能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 |
//+------------------+-----------------------------------------+---------------+

[橡木疙瘩]

引用 2 楼 kasabranca 的回复:

[quote=引用 1 楼 u010936098 的回复:] this->m_MessageId = ++this->m_MessageId % 255； this->m_MessageId在一个表达式语句中同时被赋值操作符和++操作符修改，两个修改顺序不同会得到不同的结果，因此这个表达式可能会因为使用的编译器不同而导致不同的结果。

赋值操作的优先级不是最低的吗？ 这样不能保证 一定是 先++ 后赋值么？[/quote] ++m_MessageID，这一运算有求值和副作用两部分，求值为m_MessageID+1，副作用为m_MessageID = m_MessageID + 1。 求值这一部分肯定是先运算的，从而取值为this->m_MessageID + 1,但什么时候执行++操作符的副作用——另m_MessageID的值增长1——那就不一定了，C++标准允许编译器为了优化代码而自由选择应用副作用的时机。如果这是个自定义操作符情况会好一些。 最重要的是，你到底想要让m_MessageID最后等于多少？ m_MessageID = (m_MessageID + 1)%255还是(m_MessageID + 1)%255+1？无论是哪一种，直接写出来就行了，何必要坚持用++操作符和代码检测工具较劲呢？