Thread: Binary Representation Code

Hi Guys,

Does any one see any vulnerability with this code. Pls guide.

Thanks.

Code:

#include <string.h>
#include <stdio.h>

void mydec2bin(int integer);

int main(void)
{
    int integer = 123;

    mydec2bin(integer);


    printf("\n\n\n");
    return 0;
}

void mydec2bin(int integer)
{
    unsigned int bit_pos, mask, word, nibble_space = 0;
    printf("The binary representation of %d is as follows:\n\n",integer);

    word = 8 * sizeof(int);
    mask = 1;
    mask = mask << (word - 1);



    for(bit_pos= 0; bit_pos<=word-1; bit_pos++)//for each bit position
    {

        if(nibble_space == 4)
        {
            printf("  ");
            nibble_space = 0;
        }

        if(integer & mask)
            printf("1");
        else
            printf("0");

        mask = mask >> 1;

        nibble_space++;
    }

}

Only that you should
#include <limits.h>

and do this
word = CHAR_BIT * sizeof(int);

Other than that, seems good.

>an int may contain padding bits.
Sorry Mr. Sinkula, but I'm not going to let you off the hook that easily. I believe that you're talking about trap representations and how the number of representation bits in anything but an unsigned char could be different than the total bit size of the type, which makes CHAR_BIT * sizeof ( T ) where T is anything but unsigned char a dangerous proposition. That's cool. I understand the problem and it's hard to explain to someone who doesn't also understand it, but you didn't give a viable alternative that works.

I'm a firm believer of only addressing a problem if you have a solution that's as good or better than the existing solution.

>http://www.daniweb.com/code/snippet148.html
Heheh, cop out.

That's about what I was thinking, though it doesn't accurately give you the value bits for a signed type. If you use one of the MAX macros from limits.h, you can get a loop that's useful for signed as well as unsigned types:

Code:

int n = 0;

for ( bit = INT_MAX; bit > 0; bit &= bit - 1 )
  ++n;

But even though that's a readable and correct way to get the number of value bits for a type, it's not really better than CHAR_BIT * sizeof(T) because it can't be optimized away into a compile-time constant. One of the cooler macros I've seen gives you the value bits of any 2^N-1 value. That includes the MAX macros in limits.h, so you can easily find the value bits of any integral data type.

Code:

#include <stdio.h>
#include <limits.h>

/* Brain hurting macro that I wish I had thought of */
#define value_bits(x) ((x) / ((x) % 0x3fffffffL + 1) /0x3fffffffL % 0x3fffffffL \
  * 30 + (x) % 0x3fffffffL / ((x) % 31 + 1) / 31 % 31 * 5 + 4 - 12 / ((x) % 31 + 3))

#define MAX_SIZE INT_MAX

int main ( void )
{
  unsigned int i, n = 0;

  puts ( "value_bits says:" );
  printf ( "%d representation bits\n", value_bits ( MAX_SIZE ) );

  for ( i = MAX_SIZE; i > 0; i &= i - 1 )
    ++n;

  puts ( "\nManual loop says:" );
  printf ( "%d representation bits\n", n );

  return 0;
}

Keeping to my principles, I felt the need to post what I think is a viable solution. But as a courtesy, I waited until you posted yours first, since you broached the subject.

Cheers!