user-0 提问: *string = toupper(*string++)出错的原因在哪里？

回复:
user: user-0
content: 引用 18 楼 bravery36 的回复:不要做这种未定义行为然后问为什么，不作死就不会死，老老实实多写一行不是很好吗 当你还没有成为高手的时候，也会很明白什么叫“作死”吗，会知道自己怎么死的吗？

user: user-1
content: 不要做这种未定义行为然后问为什么，不作死就不会死，老老实实多写一行不是很好吗

user: user-0
content: 如果说自增操作在语句中顺序不明，那么至少应该有输出吧？ 在toUpper函数开始处添加printf语句后，发现整个函数都没有执行。 我不知道将自增操作放入到赋值语句中后发生了什么事情，但为什么整个toUpper函数都不执行了呢？

user: user-0
content: 引用 15 楼 yangyunzhao 的回复:说个题外话，变量/参数名取个string是非常非常不好的习惯 由于该字符串没有特定功能，所以暂时没有想太多。 不过，谢谢提醒。

user: user-2
content: 引用 13 楼 a30037338 的回复:前面那句我同意， 后面这句说的就像指针自增不是一种运算一样， 只要是运算， 难道没有优先级吗？ 有优先级 但是 优先级和表达式的副作用是没有关系的 有没有加一是副作用 优先级管不到

user: user-3
content: 引用 9 楼 lin5161678 的回复:另外 ++优先级高于= 并不能得到赋值的时候指针已经加一这个判断 优先级 和 指针有没有加一 毫无关系  前面那句我同意， 后面这句说的就像指针自增不是一种运算一样， 只要是运算， 难道没有优先级吗？

user: user-4
content: 说个题外话，变量/参数名取个string是非常非常不好的习惯

user: user-0
content: 引用 9 楼 lin5161678 的回复:[quote=引用 8 楼 a30037338 的回复:] 如果不是，请说明你的见解， 而不是给个空泛的意见。 代码是错的 涉及未定义行为  你所说的 情况未必会出现   另外 ++优先级高于= 并不能得到赋值的时候指针已经加一这个判断 优先级 和 指针有没有加一 毫无关系 你根本没弄清楚优先级是干嘛的  这就是误人子弟[/quote] 如果说自增操作在语句中顺序不明，那么至少应该有输出吧？ 在toUpper函数开始处添加printf语句后，发现整个函数都没有执行。 我不知道将自增操作放入到赋值语句中后发生了什么事情，但为什么整个toUpper函数都不执行了呢？ 请给予解答，谢谢。

user: user-5
content: 表达式求值序是一个偏序，不是全序，象++/--这种很容易出问题，改掉就好，由于行为未定义，运行结果就看编译器的人品了

user: user-6
content: 同意5L，在彻底掌握++之前，实践时只把++单独写一行。

user: user-2
content: 引用 8 楼 a30037338 的回复:如果不是，请说明你的见解， 而不是给个空泛的意见。 代码是错的 涉及未定义行为  你所说的 情况未必会出现   另外 ++优先级高于= 并不能得到赋值的时候指针已经加一这个判断 优先级 和 指针有没有加一 毫无关系 你根本没弄清楚优先级是干嘛的  这就是误人子弟

user: user-3
content: 引用 6 楼 lin5161678 的回复:误人子弟的解释  请看置顶帖 学习 [/quote] 我只说一点， 造成程序崩溃的原因是不是如下解释： 后++的优先级要高于 = ， 也就是说 *string = toupper(*string++), 在赋值的时候， 指针已经加1（因为函数调用的关系，此时指针自增的值已经保存下来） 。这会造成每次赋值都给了后一位，致命的错误是最终把'\0'覆盖了， 导致下标越界。  如果不是，请说明你的见解， 而不是给个空泛的意见。

user: user-7
content: //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 | //+------------------+-----------------------------------------+---------------+

user: user-2
content: 引用 4 楼 a30037338 的回复: void toUpper(char *string) {     while('\0' != *string){         *string = toupper(*string);  //优先级的问题， 后++的优先级要高于 = ， 也就是说 *string = toupper(*string++), 在赋值的时候，                                                         //指针已经加1了， 这会造成每次赋值都给了后一位，致命的错误是最终把'\0'覆盖了， 导致下标越界。         string++;     } } 误人子弟的解释  请看置顶帖 学习

user: user-8
content: 置顶贴有说明.http://bbs.csdn.net/topics/370153775  如果看不懂就, 就永远把自加自减单独写一行.

user: user-3
content: void toUpper(char *string) {     while('\0' != *string){         *string = toupper(*string);  //优先级的问题， 后++的优先级要高于 = ， 也就是说 *string = toupper(*string++), 在赋值的时候，                                                         //指针已经加1了， 这会造成每次赋值都给了后一位，致命的错误是最终把'\0'覆盖了， 导致下标越界。         string++;     } }

user: user-2
content: 引用 1 楼 user-9 的回复:右式求值后string指针就自增了，再赋值给左式。错了  你也去看置顶帖

user: user-2
content: 看置顶帖

user: user-9
content: 右式求值后string指针就自增了，再赋值给左式。