Is memset used only for strings?

[Frederick Ding]

Hi, guys,I met a problem, Please look at the problem below:

int* bit = (int*)malloc(10 000*sizeof(int) );
memset(bit, 1, 10000*sizeof(in t));
printf("%d %d %d\n", bit[1],bit[2], bit[9999]);

Output: 16843009 16843009 16843009

Obviously I set the bit[0] to bit[9999] to 1, but it outputs are not
1's.

Why is this happen? Do I misused memset or sth else?

Any help is appreciated. Thanks!

[Richard Heathfield]

Frederick Ding said:

Hi, guys,I met a problem, Please look at the problem below:

int* bit = (int*)malloc(10 000*sizeof(int) );
int *bit = malloc(10000 * sizeof *bit);

if(bit != NULL)
{
memset(bit, 1, 10000*sizeof(in t));
Oops - that won't do what you were hoping.
printf("%d %d %d\n", bit[1],bit[2], bit[9999]);

Output: 16843009 16843009 16843009

Obviously I set the bit[0] to bit[9999] to 1, but it outputs are not
1's.

Observe this magic:

unsigned char *p = (unsigned char *)bit;
while(p < (unsigned char *)(bit + 1))
{
printf("%d\n", *p++)
}

This prints every byte in your first int. Try it, and I think you'll
understand all about memset.

--
Richard Heathfield
"Usenet is a strange place" - dmr 29/7/1999
http://www.cpax.org.uk
email: rjh at above domain (but drop the www, obviously)

[Bjørn Augestad]

Frederick Ding wrote:

Hi, guys,I met a problem, Please look at the problem below:

int* bit = (int*)malloc(10 000*sizeof(int) );
memset(bit, 1, 10000*sizeof(in t));
printf("%d %d %d\n", bit[1],bit[2], bit[9999]);

Output: 16843009 16843009 16843009

Obviously I set the bit[0] to bit[9999] to 1, but it outputs are not
1's.

Why is this happen? Do I misused memset or sth else?

Any help is appreciated. Thanks!

Your call to memset() sets each byte to 1. Your ints probably occupies 4
bytes, so you initialize each int with bit patterns 0x01010101, which
equals 16843009.

Bjørn

[Keith Thompson]

"Frederick Ding" <di*******@gmai l.com> writes:

Hi, guys,I met a problem, Please look at the problem below:

int* bit = (int*)malloc(10 000*sizeof(int) );
Don't cast the result of malloc. It can mask errors such as failing
to include <stdlib.h> or compiling C code with a C++ compiler.

The recommended idiom is:

int *bit = malloc(10000 * sizeof *bit);

You should check whether the malloc() call succeeded.
memset(bit, 1, 10000*sizeof(in t));
This sets every byte of the array to 1.
printf("%d %d %d\n", bit[1],bit[2], bit[9999]);

Output: 16843009 16843009 16843009

Obviously I set the bit[0] to bit[9999] to 1, but it outputs are not
1's.

16843009 in hexadecimal is 0x01010101.

memset() sets every byte to a specified value. There's no equivalent
standard function to set every int to a specified value.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Malcolm]

"Frederick Ding" <di*******@gmai l.com> wrote

Obviously I set the bit[0] to bit[9999] to 1, but it outputs are not
1's.

Why is this happen? Do I misused memset or sth else?

Any help is appreciated. Thanks!

memset isn't a very useful function.
It sets every byte to a given value. The only practical use, really, is to
set memory to zero, unless, as you say, you happen to want a string of
asterisks or something.
You cannot set integers to a non-zero value.
You can set pointers to NULL and floating point values to zero, but not with
complete portability (the NULL pointer isn't always all bits zero).

Your best bet is to ignore it and use a for loop, setting your array to the
values you want.

[Alex Fraser]

"Malcolm" <re*******@btin ternet.com> wrote in message
news:dm******** **@nwrdmz02.dmz .ncs.ea.ibs-infra.bt.com...
[snip]

memset isn't a very useful function.
I agree.
It sets every byte to a given value. The only practical use, really, is
to set memory to zero, unless, as you say, you happen to want a string of
asterisks or something.
You cannot set integers to a non-zero value.
AFAIK you can't portably set them to zero either, except possibly the
fixed-size ones added in C99 (uint32_t etc).
You can set pointers to NULL and floating point values to zero, but not
with complete portability (the NULL pointer isn't always all bits zero).

Neither, as I'm sure you meant, is a floating point all-bits-zero
necessarily equal to zero.

Alex

[Malcolm]

"Alex Fraser" <[e-mail] > wrote

It sets every byte to a given value. The only practical use, really, is
to set memory to zero, unless, as you say, you happen to want a string of
asterisks or something.
You cannot set integers to a non-zero value.

AFAIK you can't portably set them to zero either, except possibly the
fixed-size ones added in C99 (uint32_t etc).

int array[100];

memset(array, 0, 100 * sizeof(int));

is guaranteed to produce an array to 100 integers of value 0, on an ANSI
system.
(However if technology changes so that for some reason it doesn't make sense
to have value zero all bits clear, the ANSI standard will be a dead letter).

[Emmanuel Delahaye]

Frederick Ding a écrit :

Hi, guys,I met a problem, Please look at the problem below:

int* bit = (int*)malloc(10 000*sizeof(int) );
memset(bit, 1, 10000*sizeof(in t));
printf("%d %d %d\n", bit[1],bit[2], bit[9999]);

Output: 16843009 16843009 16843009
Many things are missing. It may work or not...
Obviously I set the bit[0] to bit[9999] to 1, but it outputs are not
1's.

Assuming the code is complete, yes there are. It will appears more
clearly like this:

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

int main(void)
{
size_t const size = 10000;
int* bit = malloc (size * sizeof *bit);

if (bit != NULL)
{
memset(bit, 1, size * sizeof *bit);
printf("%X %X %X\n"
, (unsigned) bit[1]
, (unsigned) bit[2]
, (unsigned) bit[size-1]);

free (bit), bit = NULL;
}

return 0;
}

1010101 1010101 1010101

see the pattern ?

--
A+

Emmanuel Delahaye

[Emmanuel Delahaye]

Frederick Ding a écrit :

Hi, guys,I met a problem, Please look at the problem below:

int* bit = (int*)malloc(10 000*sizeof(int) );
memset(bit, 1, 10000*sizeof(in t));
printf("%d %d %d\n", bit[1],bit[2], bit[9999]);

Output: 16843009 16843009 16843009
Many things are missing. It may work or not...

Please don't forget to free what have been allocated :

<<SYSALLOC Bloc 003D4A70 (40000 bytes) malloc'ed at line 14 of 'main.c'
not freed>>
Obviously I set the bit[0] to bit[9999] to 1, but it outputs are not
1's.

Assuming the code is complete, yes there are. It will appears more
clearly like this:

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

int main(void)
{
size_t const size = 10000;
int* bit = malloc (size * sizeof *bit);

if (bit != NULL)
{
memset(bit, 1, size * sizeof *bit);
printf("%X %X %X\n"
, (unsigned) bit[1]
, (unsigned) bit[2]
, (unsigned) bit[size-1]);

free (bit), bit = NULL;
}

return 0;
}

1010101 1010101 1010101

see the pattern ?

--
A+

Emmanuel Delahaye

[Frederick Ding]

Thanks, guys!
I'm very happy that so many kind people help me.
I've learned a lot from you, THANKS!
Yet I still have two questions:
1. malloc(10000 * sizeof *bit);
^^^^^^^^^^^^
sizeof *bit what's this, can sizeof be used like this? wow,
I can not find this expression in all of my C books.
where can I find some reference to this?
I think sizeof is a function that calculate a type's size, so it
should be used with ( ),
and the * between "sizeof" and "bit" is a pointer or a multiply? I'm
really confused.

2. I once used memset like this, and it looked like works:
memset(semi,-1,sizeof(float) *16);
memset(final,-1,sizeof(float) *16);
memset(cup,-1,sizeof(float) *16);
printf("%f %f\n",semi[0],final[15]);

Output: -1.#QNAN0 -1.#QNAN0
It seemed that it was "-1" and I omitted the topic I just asked.
Now the question is "-1.#QNAN0" means what?
what is the #QNAN0?

Thank you for your patience and time!