Гашение незначащих нулей, кто как делает? Опции

[sKWO]

Пока вижу два варианта вывода числа на ЖКИ с гашением незначащих нулей:

Код

#include <stdlib.h>
div_t dtmp;
char str_tmp[6];
str_tmp[5] = 0;  
  OborotiZaMin = (OborotiZaMinConst + (PPeriod >> 1)) / PPeriod;

#if   0

  dtmp = div(OborotiZaMin, 10);
  str_tmp[4] = dtmp.rem + '0';  
  dtmp = div(dtmp.quot, 10);
  str_tmp[3] = dtmp.rem + '0';  
  dtmp = div(dtmp.quot, 10);
  str_tmp[2] = dtmp.rem + '0';  
  dtmp = div(dtmp.quot, 10);
  str_tmp[1] = dtmp.rem + '0';  
  str_tmp[0] = dtmp.quot + '0';  
// Гашение незначащих нулей
  for (i = 0; i < 4; ++i)
    if (str_tmp[i] == '0')
      str_tmp[i] = ' ';
    else
      break;

#else
  
  i = 0;
  dtmp = div(OborotiZaMin, 10000);
  if (dtmp.quot != 0)
    str_tmp[i++] = dtmp.quot + '0';

  dtmp = div(dtmp.rem, 1000);
  if (i || (dtmp.quot != 0))
    str_tmp[i++] = dtmp.quot + '0';
    
  dtmp = div(dtmp.rem, 100);
  if (i || (dtmp.quot != 0))
    str_tmp[i++] = dtmp.quot + '0';
    
  dtmp = div(dtmp.rem, 10);
  if (i || (dtmp.quot != 0))
    str_tmp[i++] = dtmp.quot + '0';
    
  str_tmp[i++] = dtmp.rem + '0';
  str_tmp[i] = 0;
    
#endif
    // LCD_Write

Дабы на ЖКИ небыло такого, например "0750", а было такое "750".
Какой алгоритм используете?

[aesok]

Ну и унивесализм, как по радиксу, так и по количеству цифирей, естественно, пожирает ресурсы.

Код сгенерированый GCC для функции itoa предложенной alux, с фиксированым радиксом (которая на самом деле являеться utoa):

Код

.global    itoa
    .type    itoa, @function
itoa:
.LFB0:
.LM1:
.LVL0:
    push r16
    push r17
    push r28
    push r29
/* prologue: function */
/* frame size = 0 */
    movw r28,r24
    movw r16,r22
.LM2:
    ldi r18,hi8(10000)
    cpi r24,lo8(10000)
    cpc r25,r18
    brsh .L2
.LVL1:
    ldi r24,lo8(0)
.LVL2:
    rjmp .L3
.LVL3:
.L2:
.LM3:
    movw r30,r24
    subi r30,lo8(-(-10000))
    sbci r31,hi8(-(-10000))
    movw r24,r30
.LVL4:
    ldi r22,lo8(10000)
    ldi r23,hi8(10000)
    call __udivmodhi4
    movw r28,r24
.LM4:
    movw r24,r30
    ldi r22,lo8(10000)
    ldi r23,hi8(10000)
    call __udivmodhi4
    subi r22,lo8(-(49))
    movw r30,r16
    st Z+,r22
    movw r16,r30
    ldi r24,lo8(1)
.LVL5:
.L3:
.LM5:
    ldi r31,hi8(1000)
    cpi r28,lo8(1000)
    cpc r29,r31
    brsh .L4
    tst r24
    breq .L5
.L4:
    movw r24,r28
.LVL6:
    ldi r22,lo8(1000)
    ldi r23,hi8(1000)
    call __udivmodhi4
    mov r18,r22
    movw r24,r28
    ldi r22,lo8(1000)
    ldi r23,hi8(1000)
    call __udivmodhi4
    movw r28,r24
    subi r18,lo8(-(48))
    movw r30,r16
    st Z+,r18
    movw r16,r30
    ldi r24,lo8(1)
.LVL7:
.L5:
.LM6:
    cpi r28,100
    cpc r29,__zero_reg__
    brsh .L6
    tst r24
    breq .L7
.L6:
    movw r24,r28
.LVL8:
    ldi r22,lo8(100)
    ldi r23,hi8(100)
    call __udivmodhi4
    mov r18,r22
    movw r24,r28
    ldi r22,lo8(100)
    ldi r23,hi8(100)
    call __udivmodhi4
    movw r28,r24
    subi r18,lo8(-(48))
    movw r30,r16
    st Z+,r18
    movw r16,r30
    ldi r24,lo8(1)
.LVL9:
.L7:
.LM7:
    cpi r28,10
    cpc r29,__zero_reg__
    brsh .L8
    tst r24
    breq .L9
.L8:
    movw r24,r28
.LVL10:
    ldi r22,lo8(10)
    ldi r23,hi8(10)
    call __udivmodhi4
    mov r18,r22
    movw r24,r28
    ldi r22,lo8(10)
    ldi r23,hi8(10)
    call __udivmodhi4
    movw r28,r24
    subi r18,lo8(-(48))
    movw r30,r16
    st Z+,r18
    movw r16,r30
.LVL11:
.L9:
.LM8:
    movw r18,r28
    subi r18,lo8(-(48))
    movw r30,r16
    st Z+,r18
.LM9:
    movw r28,r16
.LVL12:
    std Y+1,__zero_reg__
.LM10:
    movw r24,r30
.LVL13:
/* epilogue start */
    pop r29
    pop r28
    pop r17
    pop r16
.LVL14:
    ret
.LFE0:

Код функции uitoa из avr-libc c радиксом:

Код

    X_movw    ZL, r_str_lo; &string
    X_movw    r_lstr_lo, ZL; save &string
    cpi    r_radix, 2; no radix < 2
    brlt    99f
    cpi    r_radix, 37; no radix > 36
    brge    99f    
1:
    mov    r22, r_radix; radix
    clr    r23;  dividend in r25:r24,   divisor in r23:r22
    XCALL    _U(__udivmodhi4);  quotient in r23:r22, remainder in r25:r24
    ;  clobbered: r0, r21, r26, r27
    ;  call-used but preserved: r18,r19,r20,r30,r31
    subi    r24, 0xd0; + '0'
    cpi    r24, 0x3a; > '9' ?
    brlt    10f
    subi    r24, 0xd9; + 'a' - 10 - '0'
10:
    st    Z+, r24; write char to string in reverse order!
    X_movw    r_val_lo,r22; quotient -> dividend
    sbiw    r_val_lo,0; value == 0 ?
    brne    1b
99:
    st    Z, __zero_reg__; terminate string
    X_movw    r_val_lo, r_lstr_lo; restore &string as return value
    XJMP    _U(strrev); reverse string

Обе используют __udivmodhi4, размер strrev используемой в uitoa из avr-libc - 16 инструкций.

Анатолий.

Сообщение отредактировал aesok - Aug 31 2008, 14:35

[_Pasha]

Обе используют __udivmodhi4, размер strrev используемой в uitoa из avr-libc - 16 инструкций.

Единственное замечание, что в случае большой загруженности проца, надо __udivmodhi4 срочно менять на поразрядное вычитание числа 10^n.
С точки зрения эргономики - масса вариантов: выравнивание, положение знака, правые незначащие, возникающие, если у Вас фиксированная точка. Лично я руководствуюсь критерием минимальных перемещений выводимого числа, т.к. все числовые поля должны привлекать одинаковое количество внимания оператора. С этой точки зрения, сколько цифр заложено, столько и вывожу, как правило, и ноль или другая цифра - пофиг. Формат- священная корова Исключения - имхо, если меняются не числа в фиксированных полях, а целые экраны. Тогда, ессно, пробелы вместо нулей обязательны.