Can I do ANYTHING on allocated memory?

[Sourcerer]

Does any of the following constitute undefined behavior? Once I allocate memory,
can I do with it whatever I want (as in the example, use memory allocated as
char *, as memory where I store integers)?

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

int main(void) {
char *a;
int *x, *y;
a = (char *) malloc(2 * sizeof(int));
// here's the part I'm wondering about
x = (int *) a;
y = (int *) a + sizeof(int);
*x = 10;
*y = 20;
printf ("%d %d\n", *x, *y);
return 0;
}

--
"It is easy in the world to live after the world's opinion; it easy in solitude
to live after our own; but the great man is he who in the midst of the crowd
keeps with perfect sweetness the independence of solitude."
Ralph Waldo Emerson, Self-reliance 1841
http://pinpoint.wordpress.com/

[Malcolm McLean]

"Sourcerer" <en****@MAKNIgm ail.comwrote in message

Does any of the following constitute undefined behavior? Once I allocate
memory, can I do with it whatever I want (as in the example, use memory
allocated as char *, as memory where I store integers)?

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

int main(void) {
char *a;
int *x, *y;
a = (char *) malloc(2 * sizeof(int));
// here's the part I'm wondering about
x = (int *) a;
y = (int *) a + sizeof(int);
*x = 10;
*y = 20;
printf ("%d %d\n", *x, *y);
return 0;
}

You are playing fast and loose with the C type system.
It is there to help you avoid alignment problems and other nasties, however
for backwards compatibility and certain low-level operations, C also gives
you the freedom to mess about with it.
Technically I think you are OK because pointers to char can be converted to
any other type. This is a hangover from the days when there were no void
pointers, so char *s were used instead.
However had you cast to a short *, and back, it would have been
implentation-defined behaviour. On the vast majority of machines int * and
short *s are the same and the cast is a no op. However it is just possible
that the short * throws some bits away which an int * needs, so a conforming
implementation could do anything it wants in response.

[Richard Tobin]

In article <eo**********@s s408.t-com.hr>,
Sourcerer <en****@MAKNIgm ail.comwrote:

>Once I allocate memory,
can I do with it whatever I want (as in the example, use memory allocated as
char *, as memory where I store integers)?

You didn't allocate it as char *:

a = (char *) malloc(2 * sizeof(int));

You just allocated some memory, and (unnecessarily) cast it to char *
before assigning it to a. The memory returned by malloc() doesn't
have a type.

You can store whatever you like in it, provided that it fits and you
respect the alignment rules.

x = (int *) a;

Fine.

But you have a mistake here:

y = (int *) a + sizeof(int);

You have converted a to an integer pointer, then added sizeof(int) to
it. If sizeof(int) is 4, you have just added four int sizes to it,
i.e. 16 bytes. Adding to a pointer adds in units of the size of the
pointed-to object, so you want

y = (int *) (a + sizeof(int));
or
y = (int *) a + 1;

-- Richard
--
"Considerat ion shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Richard Tobin]

In article <lK************ *********@bt.co m>,
Malcolm McLean <re*******@btin ternet.comwrote :

>You are playing fast and loose with the C type system.

No, apart from his mistake with the addition, he is using pointers
correctly.

>Technically I think you are OK because pointers to char can be converted to
any other type. This is a hangover from the days when there were no void
pointers, so char *s were used instead.

void * has replaced char * as the generic pointer type, but you can't
do arithmetic on void * pointers. char * (or unsigned char *) is the
type used to access memory as bytes, which are the units of C storage.

C guarantees that void * and char * have the same representation, but
the OP is not relying on that.

-- Richard
--
"Considerat ion shall be given to the need for as many as 32 characters
in some alphabets" - X3.4, 1963.

[Keith Thompson]

"Sourcerer" <en****@MAKNIgm ail.comwrites:

Does any of the following constitute undefined behavior? Once I
allocate memory, can I do with it whatever I want (as in the example,
use memory allocated as char *, as memory where I store integers)?

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

int main(void) {
char *a;
int *x, *y;
a = (char *) malloc(2 * sizeof(int));
// here's the part I'm wondering about
x = (int *) a;
y = (int *) a + sizeof(int);
*x = 10;
*y = 20;
printf ("%d %d\n", *x, *y);
return 0;
}

Apart from the addition of sizeof(int), which actually adds
sizeof(int)*siz eof(int) bytes to the pointer, your code looks ok as
far as I can tell. But it could be simplified considerably (and made
more robust):

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

int main(void)
{
int *x, *y;
x = malloc(2 * sizeof *x);
if (x == NULL) {
fprintf(stderr, "malloc failed\n");
exit(EXIT_FAILU RE);
}
y = x + 1;
*x = 10;
*y = 20;
printf ("%d %d\n", *x, *y);
return 0;
}

--
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.

[Sourcerer]

"Richard Tobin" <ri*****@cogsci .ed.ac.ukwrote in message
news:eo******** ***@pc-news.cogsci.ed. ac.uk...

In article <eo**********@s s408.t-com.hr>,
Sourcerer <en****@MAKNIgm ail.comwrote:

>>Once I allocate memory,
can I do with it whatever I want (as in the example, use memory allocated as
char *, as memory where I store integers)?

You didn't allocate it as char *:

>a = (char *) malloc(2 * sizeof(int));

You just allocated some memory, and (unnecessarily) cast it to char *
before assigning it to a. The memory returned by malloc() doesn't
have a type.

Why is the cast unnecessary? malloc() returns void *

You can store whatever you like in it, provided that it fits and you
respect the alignment rules.

>x = (int *) a;

Fine.

But you have a mistake here:

>y = (int *) a + sizeof(int);

Sorry, this should've been y = (int *) (a + sizeof(int));

--
"It is easy in the world to live after the world's opinion; it easy in solitude
to live after our own; but the great man is he who in the midst of the crowd
keeps with perfect sweetness the independence of solitude."
Ralph Waldo Emerson, Self-reliance 1841
http://pinpoint.wordpress.com/

[Keith Thompson]

"Sourcerer" <en****@MAKNIgm ail.comwrites:

"Richard Tobin" <ri*****@cogsci .ed.ac.ukwrote in message
news:eo******** ***@pc-news.cogsci.ed. ac.uk...

>In article <eo**********@s s408.t-com.hr>,
Sourcerer <en****@MAKNIgm ail.comwrote:

>>>Once I allocate memory,
can I do with it whatever I want (as in the example, use memory allocated as
char *, as memory where I store integers)?

You didn't allocate it as char *:

>>a = (char *) malloc(2 * sizeof(int));

You just allocated some memory, and (unnecessarily) cast it to char *
before assigning it to a. The memory returned by malloc() doesn't
have a type.

Why is the cast unnecessary? malloc() returns void *

[...]

See question 7.7b in the comp.lang.c FAQ, <http://www.c-faq.com/>.
Questions 7.6, 7.7, and 7.7c are also relevant.

--
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.

[Martin Ambuhl]

Sourcerer wrote:

Does any of the following constitute undefined behavior? Once I allocate
memory, can I do with it whatever I want (as in the example, use memory
allocated as char *, as memory where I store integers)?

Please try to indent code so it is readable. Luckily, your example is
small enough this time, so we can proceed with cleaning that up.

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

int main(void) {
char *a;
int *x, *y;
a = (char *) malloc(2 * sizeof(int));

^^^^^^^^
This C++-ism is unnecessary and bad practice in C.

// here's the part I'm wondering about

^^
C++-style comments introduced with '//' will not work with C89
compilers, and are a bad idea for code that you post, since your only
protection against line-wrap problems is keeping comments short, as you
have done.

x = (int *) a;

Because malloc returns space suitable aligned for any type, the above
will fly, but

y = (int *) a + sizeof(int);

Did you check to see where this actually pointed? (int *)a is an int
pointer; the next int will be at (int *)a + 1.

*x = 10;
*y = 20;

You may not own the place y currently points.

printf ("%d %d\n", *x, *y);
return 0;
}

Try this modified version of your code to see what the above comments
reflect:
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
char *a;
int *x, *y;
a = (char *) malloc(2 * sizeof(int));

x = (int *) a;

printf("The pointer-to-char a contains: %p\n"
"The pointer-to-int x = (int *)a contains: %p\n"
"The value of (int *)a + sizeof(int) is %p\n"
"The value of (int *)a + 1 is %p\n",
(void *) a, (void *) x, (void *) ((int *) a + sizeof(int)),
(void *) ((int *) a + 1));

y = (int *) a + sizeof(int);
*x = 10;
#if 0
/* I am not even going to try to assign to *y, as assigned above */
*y = 20;
/* or try to print its value */
printf("%d %d\n", *x, *y);
#endif
/* but this would be ok */
y = x + 1;
*y = 20;
printf("%d %d\n", *x, *y);

return 0;
}
[The results on one implementation]
The pointer-to-char a contains: 20d90
The pointer-to-int x = (int *)a contains: 20d90
The value of (int *)a + sizeof(int) is 20da0
The value of (int *)a + 1 is 20d94
10 20

[isobelievein]

Richard Tobin well.

[Jack Klein]

On Thu, 11 Jan 2007 22:50:40 -0000, "Malcolm McLean"
<re*******@btin ternet.comwrote in comp.lang.c:

>
"Sourcerer" <en****@MAKNIgm ail.comwrote in message

Does any of the following constitute undefined behavior? Once I allocate
memory, can I do with it whatever I want (as in the example, use memory
allocated as char *, as memory where I store integers)?

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

int main(void) {
char *a;
int *x, *y;
a = (char *) malloc(2 * sizeof(int));
// here's the part I'm wondering about
x = (int *) a;
y = (int *) a + sizeof(int);
*x = 10;
*y = 20;
printf ("%d %d\n", *x, *y);
return 0;
}

You are playing fast and loose with the C type system.

No, he is not, although he is risking undefined behavior if the
allocation fails and malloc() returns a null pointer, and as others
have pointed out his arithmetic for calculating the value to assign to
'y' is incorrect unless he happens to be on a platform where
sizeof(int) is 1.

It is there to help you avoid alignment problems and other nasties, however
for backwards compatibility and certain low-level operations, C also gives
you the freedom to mess about with it.
Technically I think you are OK because pointers to char can be converted to
any other type. This is a hangover from the days when there were no void

malloc() returns a pointer to void, and pointers to void and to char
are guaranteed to have the same size and representation. So assigning
the returned address to a pointer to char does not change it at all.

pointers, so char *s were used instead.
However had you cast to a short *, and back, it would have been
implentation-defined behaviour. On the vast majority of machines int * and
short *s are the same and the cast is a no op. However it is just possible
that the short * throws some bits away which an int * needs, so a conforming
implementation could do anything it wants in response.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.l earn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html