conversion into hexadecimal values

[sweeet_addiction16]

hello
im programming in c.i have to write about 100 hexadecimal values in to
a file. how do i do it?pls help me

 

[osmium]

im programming in c.i have to write about 100 hexadecimal values in to
a file. how do i do it?pls help me

Computer files consist of 1's and 0's. Hexadecimal is a *representation* of
a number. I suggest you read the article in the link,reformulate your
question if you still have one, and post again.

http://en.wikipedia.org/wiki/Hexadecimal

 

[Chris Dollin]

hello
im programming in c.i have to write about 100 hexadecimal values in to
a file. how do i do it?pls help me

Pls hlp s b spllgn ll r wrds t prprl. Thk w.

There are no "hexadecimal values"; there are integer values which may be
represented in hexadecimal. If you have a (n unsigned) value you want to
write in hexadecimal, you can use the %x format conversion of [f]printf.
If you have several, you can write them one at a time, and it would
probably make sense to use a loop to do this.

If you're not familiar with `[f]printf` and format conversions, become
so: they'll be documented in any decent C book, your man pages if you're
on a Unixy box, and you can probably google for them too.

 

[Richard Heathfield]

Chris Dollin said:

There are no "hexadecimal values";

You could, however, be forgiven for thinking there are, if you were
reading the C Standard. It is a little loose in its terminology at
times.

<snip>

 

[sweeet_addiction16]

Computer files consist of 1's and 0's. Hexadecimal is a *representation* of
a number. I suggest you read the article in the link,reformulate your
question if you still have one, and post again.

http://en.wikipedia.org/wiki/Hexadecimal

im sorry ..may be my question wasnt tht clear.i have to write the
following values into a file(say using fwrite)

4d 54 68 64 00 00 00 06 00 00 00 01 00 80 4d 54 72 6b 00 00 00 8c 00
ff 58
04 04 02 30 08 00 ff 59 02 00 00 00 90 3c 28 81 00 90 3c 00 00 90 3c
1e 81
00 90 3c 00 00 90 43 2d 81 00 90 43 00 00 90 43 32 81 00 90 43 00 00
90 45
2d 81 00 90 45 00 00 90 45 32 81 00 90 45 00 00 90 43 23 82 00 90 43
00 00
90 41 32 81 00 90 41 00 00 90 41 2d 81 00 90 41 00 00 90 40 32 40 90
40 00
40 90 40 28 40 90 40 00 40 90 3e 2d 40 90 3e 00 40 90 3e 32 40 90 3e
00 40
90 3c 1e 82 00 90 3c 00 00 ff 2f 00
all these values are to be written into a file
how do i do it?

 

[Walter Roberson]

im sorry ..may be my question wasnt tht clear.i have to write the
following values into a file(say using fwrite)

4d 54 68 64 00 00 00 06 00 00 00 01 00 80 4d 54 72 6b 00 00 00 8c 00
ff 58 [...]

all these values are to be written into a file
how do i do it?

Code fragment:

unsigned char outputbuffer[] = {
0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
0x01, 0x00, 0x80, 0x4d, 0x54, 0x72, 0x6b, 0x00, 0x00, 0x00, 0x8c, [etc]
};

filestream = fopen('filename', 'w');
fwrite(outputbuffer, sizeof outputbuffer, 1, filestream);

 

[Ben Pfaff]

filestream = fopen('filename', 'w');

Both of these should be "string literals", not 'character
constants'.

 

[Walter Roberson]

(e-mail address removed)-cnrc.gc.ca (Walter Roberson) writes:

Both of these should be "string literals", not 'character
constants'.

Opps, you are right. I've been programming in Matlab a lot lately,
which uses '' for string literals.

 

[CBFalconer]

im programming in c.i have to write about 100 hexadecimal values
in to a file. how do i do it?pls help me

This may be helpful:

/* Routines to display values in various bases */
/* with some useful helper routines. */
/* by C.B. Falconer, 19 Sept. 2001 */
/* Released to public domain. Attribution appreciated */

#include <stdio.h>
#include <string.h>
#include <limits.h> /* ULONG_MAX etc. */

/* ======================= */
/* reverse string in place */
size_t revstring(char *stg)
{
char *last, temp;
size_t lgh;

lgh = strlen(stg);
if (lgh > 1) {
last = stg + lgh; /* points to '\0' */
while (last-- > stg) {
temp = *stg; *stg++ = *last; *last = temp;
}
}
return lgh;
} /* revstring */

/* ============================================ */
/* Mask and convert digit to hex representation */
/* Output range is 0..9 and a..f only */
int hexify(unsigned int value)
{
static char hexchars[] = "0123456789abcdef";

return (hexchars[value & 0xf]);
} /* hexify */

/* ================================================== */
/* convert unsigned number to string in various bases */
/* 2 <= base <= 16, controlled by hexify() */
/* Returns actual output string length */
size_t basedisplay(unsigned long number, unsigned int base,
char *stg, size_t maxlgh)
{
char *s;

/* assert (stg[maxlgh]) is valid storage */
s = stg;
if (maxlgh && base)
do {
*s = hexify(number % base);
s++;
} while (--maxlgh && (number = number / base) );
*s = '\0';
revstring(stg);
return (s - stg);
} /* basedisplay */

/* ================================================ */
/* convert signed number to string in various bases */
/* 2 <= base <= 16, controlled by hexify() */
/* Returns actual output string length */
size_t signbasedisplay(long number, unsigned int base,
char * stg, size_t maxlgh)
{
char *s;
size_t lgh;
unsigned long n;

s = stg; lgh = 0;
n = (unsigned long)number;
if (maxlgh && (number < 0L)) {
*s++ = '-';
maxlgh--;
n = -(unsigned long)number;
lgh = 1;
}
lgh = lgh + basedisplay(n, base, s, maxlgh);
return lgh;
} /* signbaseddisplay */


/* ==================== */
/* flush to end-of-line */
int flushln(FILE *f)
{
int ch;

while ('\n' != (ch = fgetc(f)) && (EOF != ch)) /* more */;
return ch;
} /* flushln */

/* ========== END of generically useful routines ============ */

/* ========================= */
/* Prompt and await <return> */
static void nexttest(char *prompt)
{
static char empty[] = "";

if (NULL == prompt) prompt = empty;
printf("\nHit return for next test: %s", prompt);
fflush(stdout);
flushln(stdin);
} /* nexttest */

/* ============================== */
/* Display a value and its length */
static void show(char *caption, int sz, char *stg)
{

if ((unsigned)sz != strlen(stg))
printf("Something is wrong with the sz value\n");
printf("%s: sz = %2d \"%s\"\n", caption, sz, stg);
} /* show */

/* =========== */
/* exercise it */
int main(void)
{
#define LGH 40
#define VALUE 1234567890

char stg[LGH];
unsigned int base;
int sz;

printf("\nExercising basedisplay routine\n");
printf("\nbase sz value\n");
for (base = 2; base <= 16; base++) {
sz = (int)basedisplay(VALUE, base, stg, LGH - 1);
printf("%2d %2d %s\n", base, sz, stg);
}

nexttest("ULONG_MAX");
for (base = 8; base <= 16; base++) {
sz = (int)basedisplay(ULONG_MAX, base, stg, LGH - 1);
printf("%2d %2d %s\n", base, sz, stg);
}

basedisplay(0, 10, stg, 3);
printf("\nzero %s\n", stg);

basedisplay(VALUE, 10, stg, 3);
printf("3 lsdigits only, base 10 %s\n", stg);

printf("\nBad calls:\n");

sz = (int)basedisplay(VALUE, 10, stg, 0);
show("0 length field", sz, stg);

sz = (int)basedisplay(VALUE, 1, stg, 20);
show("base 1, lgh 20", sz, stg);

sz = (int)basedisplay(VALUE, 0, stg, 20);
show("base 0, lgh 20", sz, stg);

sz = (int)signbasedisplay(-1234, 10, stg, 0);
show("0 lgh fld, -ve", sz, stg);

sz = (int)signbasedisplay(-1234, 10, stg, 2);
show("truncate -1234", sz, stg);

nexttest("System limits");

sz = (int)signbasedisplay(SCHAR_MIN, 10, stg, 20);
show("SCHAR_MIN ", sz, stg);

sz = (int)signbasedisplay(SCHAR_MAX, 10, stg, 20);
show("SCHAR_MAX ", sz, stg);

sz = (int)signbasedisplay(UCHAR_MAX, 10, stg, 20);
show("UCHAR_MAX ", sz, stg);

sz = (int)signbasedisplay(CHAR_MIN, 10, stg, 20);
show("CHAR_MIN ", sz, stg);

sz = (int)signbasedisplay(CHAR_MAX, 10, stg, 20);
show("CHAR_MAX ", sz, stg);

sz = (int)signbasedisplay(MB_LEN_MAX, 10, stg, 20);
show("MB_LEN_MAX ", sz, stg);

sz = (int)signbasedisplay(SHRT_MIN, 10, stg, 20);
show("SHRT_MIN ", sz, stg);

sz = (int)signbasedisplay(SHRT_MAX, 10, stg, 20);
show("SHRT_MAX ", sz, stg);

sz = (int)signbasedisplay(USHRT_MAX, 10, stg, 20);
show("USHRT_MAX ", sz, stg);

sz = (int)signbasedisplay(INT_MIN, 10, stg, 20);
show("INT_MIN ", sz, stg);

sz = (int)signbasedisplay(INT_MAX, 10, stg, 20);
show("INT_MAX ", sz, stg);

sz = (int)signbasedisplay(INT_MAX, 10, stg, 20);
show("INT_MAX ", sz, stg);

sz = (int) basedisplay(UINT_MAX, 10, stg, 20);
show("UINT_MAX ", sz, stg);

sz = (int)signbasedisplay(LONG_MIN, 10, stg, 20);
show("LONG_MIN ", sz, stg);

sz = (int)signbasedisplay(LONG_MAX, 10, stg, 20);
show("LONG_MAX ", sz, stg);

sz = (int) basedisplay(ULONG_MAX, 10, stg, 20);
show("ULONG_MAX ", sz, stg);

nexttest("DONE");
return 0;
} /* main */

 

[Tor Rustad]

hello
im programming in c.i have to write about 100 hexadecimal values in to
a file. how do i do it?pls help me

I guess you want to write binary data as a hex string...


void write_hex(FILE *out, unsigned char *binary, size_t binary_len)
{
size_t i;

for (i=0; i<binary_len; i++)
fprintf(out, "%02X", (int)binary);
}

 

[Barry Schwarz]

hello
im programming in c.i have to write about 100 hexadecimal values in to
a file. how do i do it?pls help me

I guess you want to write binary data as a hex string...


void write_hex(FILE *out, unsigned char *binary, size_t binary_len)
{
size_t i;

for (i=0; i<binary_len; i++)
fprintf(out, "%02X", (int)binary);

The cast should not be necessary.

}

Remove del for email

 

[Keith Thompson]

hello
im programming in c.i have to write about 100 hexadecimal values in to
a file. how do i do it?pls help me

I guess you want to write binary data as a hex string...


void write_hex(FILE *out, unsigned char *binary, size_t binary_len)
{
size_t i;

for (i=0; i<binary_len; i++)
fprintf(out, "%02X", (int)binary);

The cast should not be necessary.

}

Personally, I'd cast it to unsigned rather than to int.

The "%02X" format requires an unsigned arguments. 'binary' is of
type unsigned char, which will normally promote to signed int (but it
could promote to unsigned int if sizeof(int)==1, which implies
CHAR_BIT>=16).

An int argument (as long as it's non-negative) *should* be acceptable
when an unsigned int is expected. I don't remember off the top of my
head whether the standard explicitly guarantees this or just says in a
footnote that it's intended to work.

This is one of the rare cases where I'd be confortable with a cast,
but to unsigned int, not to int.

 

[Tor Rustad]

]

void write_hex(FILE *out, unsigned char *binary, size_t binary_len)
{
size_t i;

for (i=0; i<binary_len; i++)
fprintf(out, "%02X", (int)binary);

The cast should not be necessary.

The cast should be (unsigned int).

I don't use energy on whether it's needed or not, it's just old habit to
put the cast there, to get a lint clean compile.