这段英文原文如下：

Corrected: in rare cases a signed compare with unsigned char treated the unsigned char as signed. This happens if the unsigned char value results from a calculated assignment. Example:
char i;
unsigned char uc0 = 254;
char c1 = 0;

void main() {
  if (c1 <= (uc0 += c1))    // uc0 is wrongly treated signed => -2 therefore the condition (0 <= -2) is false
    i = 1;
  else
    i = 0;
}
Wrong code was generated:
0000 E500        R     MOV     A,uc0
0002 2500        R     ADD     A,c1
0004 F500        R     MOV     uc0,A
0006 D3                SETB    C
0007 6480              XRL     A,#080H      
0009 F8                MOV     R0,A          |
000A E500        R     MOV     A,c1          |
000C 6480              XRL     A,#080H       |
000E 98                SUBB    A,R0          |
000F 5004              JNC     ?C0001        -> signed char compare
0011 750001      R     MOV     i,#01H
0014 22                RET
0015         ?C0001:
0015 E4                CLR     A
0016 F500        R     MOV     i,A
0018         ?C0003:
0018 22                RET
The correct code is much longer because according to the C standard a cast to int is necessary:
0000 E500        R     MOV     A,uc0
0002 2500        R     ADD     A,c1
0004 FF                MOV     R7,A
0005 F500        R     MOV     uc0,A
0007 AD00        R     MOV     R5,c1         
0009 ED                MOV     A,R5          |
000A 33                RLC     A             |
000B 95E0              SUBB    A,ACC         |
000D FC                MOV     R4,A          -> cast of signed char to int
000E D3                SETB    C            
000F ED                MOV     A,R5          |
0010 9F                SUBB    A,R7          |
0011 7480              MOV     A,#080H       +> implicit cast of unsigned char to int
0013 F8                MOV     R0,A          |
0014 6C                XRL     A,R4          |
0015 98                SUBB    A,R0          |
0016 5004              JNC     ?C0001        -> signed int compare
0018 750001      R     MOV     i,#01H
001B 22                RET
001C         ?C0001:
001C E4                CLR     A
001D F500        R     MOV     i,A
001F         ?C0003:
001F 22                RET
To generate smaller code the signedness of the values to be compared should be the same:
...
        if ((unsigned char)c1 <= (uc0 += c1))
...
0000 E500        R     MOV     A,uc0
0002 2500        R     ADD     A,c1
0004 FF                MOV     R7,A
0005 F500        R     MOV     uc0,A
0007 E500        R     MOV     A,c1
0009 D3                SETB    C            
000A 9F                SUBB    A,R7          |
000B 5004              JNC     ?C0001        -> unsigned char compare
000D 750001      R     MOV     i,#01H
0010 22                RET
0011         ?C0001:
0011 E4                CLR     A
0012 F500        R     MOV     i,A
0014         ?C0003:
0014 22                RET

我自己一般不把有符号和无符号数直接比较，一直担心这个问题，果然是雷。

这个坑有点大。

这么。。。。大的坑。

makesoft 发表于 2019-8-21 21:27
我自己一般不把有符号和无符号数直接比较，一直担心这个问题，果然是雷。 ...

以前没有注意到这一点，好在这不是每次比较都会出现问题。但总是不放心。
如果程序中是两个变量（一个有符号，一个无符号）做比较时，还能够注意到。但一个无符号变量与常数比较时，就会忽视。

按说明中，要加强制转换，才能生成比较简洁的汇编代码，否则代码会增加的。

我在另外一个帖子中有例子。现在要这样写代码，常数也要强制转换，才能生成简洁代码。

// time0 中断服务，中断时间为50us, 运行模式12T
       uchar time_1k_counter,time_100hz_counter,time_10hz_counter;
       bit time_key_ok;

      void Int_time0(void) interrupt T0_VECTOR
      {
        if(++time_1k_counter >= (uchar)10)
        {
          clk_1k = !clk_1k;
          time_1k_counter = 0;
          if (++time_100hz_counter >= (uchar)10)
          {
            clk_100hz = !clk_100hz;
            time_100hz_counter = 0;
            time_key_ok = true;
            if (++time_10hz_counter >= (uchar)10)
            {
              clk_10hz = !clk_10hz;
              time_10hzcounter = 0;
            }
          }
       }
    }