We help IT Professionals succeed at work.

Expressing number in hexadecimal number??

ee9553
ee9553 asked
on
Medium Priority
637 Views
Last Modified: 2008-03-06
Hi,

I like to ask a question about expressing number in hexadecimal format?( I think, it is hexadecimal).  Why can't we use integer and float number?

What are the good reasons reason behind this?  Can I convert this back to integer number?  For example,

  //----------------------------------------------------//
 static unsigned long SP1[64]  = {

 0x01010400L,0x00000000L,0x00010000L,0x01010404L,
 0x01010004L,0x00010404L,0x00000004L,0x00010000L,
 0x00000400L,0x01010400L,0x01010404L,0x00000400L,
 0x01000404L,0x01010004L,0x01000000L,0x00000004L,
 0x00000404L,0x01000400L,0x01000400L,0x00010400L,
 0x00010400L,0x01010000L,0x01010000L,0x01000404L,
 0x00010004L,0x01000004L,0x01000004L,0x00010004L,
 0x00000000L,0x00000404L,0x00010404L,0x01000000L,
 0x00010000L,0x01010404L,0x00000004L,0x01010000L,
 0x01010400L,0x01000000L,0x01000000L,0x00000400L,
 0x01010004L,0x00010000L,0x00010400L,0x01000004L,
 0x00000400L,0x00000004L,0x01000404L,0x00010404L,
 0x01010404L,0x00010004L,0x01010000L,0x01000404L,
 0x01000004L,0x00000404L,0x00010404L,0x01010400L,
 0x00000404L,0x01000400L,0x01000400L,0x00000000L,
 0x00010004L,0x00010400L,0x00000000L,0x01010004L   };

Thank you very much for answering my question?
 
Comment
Watch Question

ozo
CERTIFIED EXPERT
Most Valuable Expert 2014
Top Expert 2015

Commented:
static unsigned long SP1[64]  = {
    16843776L,0L,65536L,16843780L,
    16842756L,66564L,4L,65536L,
    1024L,16843776L,16843780L,1024L,
    16778244L,16842756L,16777216L,4L,
    1028L,16778240L,16778240L,66560L,
    66560L,16842752L,16842752L,16778244L,
    65540L,16777220L,16777220L,65540L,
    0L,1028L,66564L,16777216L,
    65536L,16843780L,4L,16842752L,
    16843776L,16777216L,16777216L,1024L,
    16842756L,65536L,66560L,16777220L,
    1024L,4L,16778244L,66564L,
    16843780L,65540L,16842752L,16778244L,
    16777220L,1028L,66564L,16843776L,
    1028L,16778240L,16778240L,0L,
    65540L,66560L,0L,16842756L  
};

Commented:
Unlock this solution and get a sample of our free trial.
(No credit card required)
UNLOCK SOLUTION

Commented:
Integers are always stored as binary numbers.  Regardless of the base you use to enter them (decimal (normal), hexedecimal, or octal), they are converted to a binary number and stored.  C++ doesn't "keep track" of the base in which you entered them.  Thus the two integers

int i1 = 16;
int i2 = 0x10;

are the same.  Integers can be displayed (like using printf()) in a variety of bases.  They do not have to be displayed in the base they were entered in.

Commented:
opps, hit submit by mistake.

thus you can enter an integer in one base and print it in another, like

int i = 32;
printf( "%d %x", i,i );

will print the number in both decimal and hex eventhough it was entered in decimal.

Commented:
Nietod,

Don't you wish you could hit tab and actually tab the text instead of going to the submit button?? :)

Phillip

Commented:
That wasn't the problem.  I have 4 computers.    I temporarily switched away from the modem computer but I clicked its mouse by mistake rather then the one for the computer I intended to use.

Commented:
>> Why can't we use integer and float number?
You can but sometimes it is easier (yes, you read it right) to use hex.

Consider a 32bit integer that holds a bitmask.   That is, each bit acts as a flag (the actual value of the integer is not important).

Suppose I want to turn on some bits and turn off some others.  If C/C++ supported binary format (which it doesn't) I could have written something like:

    flags = [0100101011100001]

However, since binary is not available, one can use hex.  A hex digit corresponds to 4 binary digits.  Thus:

    flags = [0100] [1010] [1110] [0001]

And in hex (this will compile):

    flags = 0x4AE1;

This is for the average human easier to translate back to binary than:

    flags =  19169;

Doesn't it?

Also consider this:

    unsigned long val =  4294967295;

See?  Probably not...  However, once I switch to hex:

    unsigned long val =  0xFFFFFFFF;

It becomes clear that 'val' holds the largest unsigned 32bit value.

All that aside, the real reason is that we C/C++ programmers worry about job security and thus try as hard as we can to make our code incomprehensible to the uninitiated.  Unfortunaly we cwnnot yet program in sanscrit and use base 17 calculations.
Unlock the solution to this question.
Thanks for using Experts Exchange.

Please provide your email to receive a sample view!

*This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply.

OR

Please enter a first name

Please enter a last name

8+ characters (letters, numbers, and a symbol)

By clicking, you agree to the Terms of Use and Privacy Policy.