Thread: void showbits(int) Definition

Read up on bitwise operators.

Originally Posted by rm82co

what is ANDMask

A bit mask, i.e., a sequence of bits used to toggle specific bits in another sequence of bits.

Originally Posted by rm82co

why do we need to find an AND MASK

So that we can turn off (unset, set to zero) all the bits except the one we want to examine on that iteration.

Originally Posted by rm82co

k will be 0 or 1

No, k will be 0 or an integral power of 2.

@rm84co, a mask is an object people use to hide parts of their faces (or all of it). By analogy, a bit mask is a set of bits used to hide (or change) another set of bits.

When you use AND operation, if one of the operands is 1, the result will be the other operand... Example: 1 and 0 = 0, 1 and 1 = 1.
If one of the operands is 0, the result is always zero: 0 and 0 = 0, 0 and 1 = 0... So bit bit is masked.

You can use AND to isolate individual bits. for instance, if I want to know only the value of bit 0, masking all the other bits, I can do:

Code:

y = 1 & x;

Here, y will have all its bits zeroed, except bit 0. Bit 0 will be a copy of x's bit 0.

If you want to mask all the bits, except bit 2, for example, you can do:

Code:

y = 4 & x;

Because 4 is 0b000...00000100. The mask has only bit 2 set... To simplify you can do something like this:

Code:

y = (1 << 2) & x;

The (1 << 2) will set the appropriate bit and it is a constant.

Knowing this you could write a code like this to show all the bits, individually, of an integer:

Code:

void show_int_bits( int x )
{
  // We'll print all bits of x.
  unsigned int bit_count = 8 * sizeof x;

  // will mask all bits, except the highest.
  unsigned int bit_mask = 1U << (sizeof(int)*8 - 1);

  while ( bit_count-- )
  {
    // (x & bit_mask) will be 0 if higherst bit of x is 0
    // or will be different from 0 if highest bit of x is 1.
    putchar( x & bit_mask ? '1' : '0' );

    // shift all bits to the left, 1 step.
    x <<= 1;
  }

}

Got it?

Yes, your showbits() is correct too. There is a small thing you should pay attention using right shifts on signed integer types: There is 2 types of right shifts: arithmetic and logical. Probably the compiler will use the arithmetic kind, but the standard says this is "implementation defined". In your routine this doesn't matter, since you are masking all bits except bit 0, after the shift.

The difference between my implementation and yours is that I prefer to mask all but the most significant bit, shifting left 1 bit per loop iteration, because I learned to avoid that "implementation defined" behavior, for the sake of portability (that's why I use sizeof(int)*8 and 8*sizeof x to get bit counts. I could use the constant 32).

This is not a criticism, as I said, your routine is correct! But mine, on x86-64, is a little better (side by side listing in assembly):

Code:

showbits_rm82co:          showbits_fred:
    push  rbp                 push   rbp
    push  rbx                 push   rbx
    mov   ebp, edi            mov    ebp, edi
    mov   ebx, 31             mov    ebx, 32
    sub   rsp, 8              sub    rsp, 8
    jmp   .L4             .L12:
.L9:                          mov    edi, ebp
    mov   edi, '0'            mov    rsi, QWORD [rip+stdout]
    sub   ebx, 1              add    ebp, ebp
    call  putchar@PLT         shr    edi, 31
    cmp   ebx, -1             add    edi, '0'
    je    .L8                 call   _IO_putc@PLT
.L4:                          sub    ebx, 1
    bt    ebp, ebx            jne    .L12
    jnc   .L9                 add    rsp, 8
    mov   edi, '1'            pop    rbx
    sub   ebx, 1              pop    rbp
    call  putchar@PLT         ret
    cmp   ebx, -1
    jne   .L4
.L8:
    add   rsp, 8
    pop   rbx
    pop   rbp
    ret

Notice, in my routine, there is only one call to _IO_putc (more efficient than putchar) and less jumps... You can archive the same result making this change:

Code:

// bit == 0 ? printf("0") : printf("1");
putchar( bit == 0 ? '0' : '1' );

PS: YOUR routine is way more efficient than mine on ARM!

Code:

showbits_rm82co:               showbits_fred:           
  push  {r4, r5, r6, lr}         push  {r4, r5, r6, lr}
  mov r5, r0                     mov r5, r0
  mov r4, #31                    ldr r6, .L19
.L4:                             mov r4, #32
  asr r3, r5, r4                 b .L14
  mov r0, #48                  .L11:
  tst r3, #1                     ldr r3, [r2]
  movne r0, #49                  subs  r4, r4, #1
  bl  putchar                    lsl r5, r5, #1
  subs  r4, r4, #1               add r0, r3, #1
  bcs .L4                        str r0, [r2]
  pop {r4, r5, r6, lr}           strb  r1, [r3]
  bx  lr                         beq .L18
                               .L14:
                                 ldr r0, [r6]
                                 cmp r5, #0
                                 movlt r1, #49
                                 movge r1, #48
                                 ldr r2, [r0, #8]
                                 ldr r3, [r2, #8]
                                 sub r3, r3, #1
                                 cmp r3, #0
                                 str r3, [r2, #8]
                                 bge .L11
                                 ldr ip, [r2, #24]
                                 cmp r3, ip
                                 bge .L11
                                 bl  __swbuf_r
                                 subs  r4, r4, #1
                                 lsl r5, r5, #1
                                 bne .L14
                               .L18:
                                 pop {r4, r5, r6, lr}
                                 bx  lr

[]s
Fred