cast in memcpy()

[Amarendra GODBOLE]

Hi,

I am a bit confused over the correct usage of memcpy(). Kindly help me
clear the confusion.

The linux manpage for memcpy(3) gives me the following prototype of
memcpy(3):
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);

Now, I have a char array (char arr[256]), and a pointer to a structure
(PSMessage *p). I have to memcpy() the contents of this structure to
the char array. I am doing it like this:

memcpy(arr, p, sizeof *p);

Someone tells me -- this is an incorrect usage, you either need to do
memcpy(arr, (char *)p, sizeof *p);
or
memcpy((void *)arr, (void *)p, sizeof *p);

Do I need the cast here ? Or the way I am trying to do it is correct ?
I have not tested the code, so I am not sure of it either.

Thanks in advance.

Cheers,
Amarendra

--
Life's battles don't always go to the stronger or the faster man,
But sooner or later the man who wins is the man who thinks he can.

[Ben Pfaff]

ro**@zworg.com (Amarendra GODBOLE) writes:

memcpy(arr, p, sizeof *p);

Someone tells me -- this is an incorrect usage, you either need to do
memcpy(arr, (char *)p, sizeof *p);
or
memcpy((void *)arr, (void *)p, sizeof *p);

Your informant is wrong. No such casts are necessary in C.
--
int main(void){char p[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv wxyz.\
\n",*q="kl BIcNBFr.NKEzjwCIxNJC";int i=sizeof p/2;char *strchr();int putchar(\
);while(*q){i+=strchr(p,*q++)-p;if(i>=(int)sizeof p)i-=sizeof p-1;putchar(p[i]\
);}return 0;}

[Martin Ambuhl]

Amarendra GODBOLE wrote:

Hi,

I am a bit confused over the correct usage of memcpy(). Kindly help me
clear the confusion.

The linux manpage for memcpy(3) gives me the following prototype of
memcpy(3):
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);

Now, I have a char array (char arr[256]), and a pointer to a structure
(PSMessage *p). I have to memcpy() the contents of this structure to
the char array. I am doing it like this:

memcpy(arr, p, sizeof *p);

Someone tells me -- this is an incorrect usage, you either need to do
memcpy(arr, (char *)p, sizeof *p);
or
memcpy((void *)arr, (void *)p, sizeof *p);

Do I need the cast here ? Or the way I am trying to do it is correct ?
I have not tested the code, so I am not sure of it either.

That "someone" is blowing smoke or else using a language other than C.
Your form is just fine.

[Greg Barron]

On Sun, 29 Feb 2004 20:14:52 -0800, Ben Pfaff <bl*@cs.stanford.edu> wrote:

ro**@zworg.com (Amarendra GODBOLE) writes:

memcpy(arr, p, sizeof *p);

Someone tells me -- this is an incorrect usage, you either need to do
memcpy(arr, (char *)p, sizeof *p);
or
memcpy((void *)arr, (void *)p, sizeof *p);

Your informant is wrong. No such casts are necessary in C.

To be more specific, no casts are required to convert any pointer type to
or from void *.

Cheers,
--
Greg.

[Richard Bos]

ro**@zworg.com (Amarendra GODBOLE) wrote:

The linux manpage for memcpy(3) gives me the following prototype of
memcpy(3):
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n); memcpy(arr, p, sizeof *p);

Someone tells me -- this is an incorrect usage, you either need to do
memcpy(arr, (char *)p, sizeof *p);
or
memcpy((void *)arr, (void *)p, sizeof *p);

That someone is wrong. Unlike, for example, C++, the C language does not
require the casts. IMO, this is a point where C is clearly superior.

Richard

[Martin Dickopp]

Greg Barron <gr*********@bigfoot.NOGARBAGE.com> writes:

On Sun, 29 Feb 2004 20:14:52 -0800, Ben Pfaff <bl*@cs.stanford.edu> wrote:

ro**@zworg.com (Amarendra GODBOLE) writes:

memcpy(arr, p, sizeof *p);

Someone tells me -- this is an incorrect usage, you either need to do
memcpy(arr, (char *)p, sizeof *p);
or
memcpy((void *)arr, (void *)p, sizeof *p);

Your informant is wrong. No such casts are necessary in C.

To be more specific, no casts are required to convert any pointer type
to or from void *.

That only applies to pointers to objects, but not to function pointers.
The latter cannot be converted to `void *' (or vice versa) at all.

Martin
--
,--. Martin Dickopp, Dresden, Germany ,= ,-_-. =.
/ ,- ) http://www.zero-based.org/ ((_/)o o(\_))
\ `-' `-'(. .)`-'
`-. Debian, a variant of the GNU operating system. \_/

[pete]

Martin Dickopp wrote:

Greg Barron <gr*********@bigfoot.NOGARBAGE.com> writes:

On Sun, 29 Feb 2004 20:14:52 -0800,
Ben Pfaff <bl*@cs.stanford.edu> wrote:

ro**@zworg.com (Amarendra GODBOLE) writes:

memcpy(arr, p, sizeof *p);

Someone tells me
-- this is an incorrect usage, you either need to do
memcpy(arr, (char *)p, sizeof *p);
or
memcpy((void *)arr, (void *)p, sizeof *p);

Your informant is wrong. No such casts are necessary in C.

To be more specific,
no casts are required to convert any pointer type
to or from void *.

That only applies to pointers to objects,
but not to function pointers.
The latter cannot be converted to `void *' (or vice versa) at all.

A cast is required when converting from (const void *) to (void *).

--
pete

[Kelsey Bjarnason]

[snips]

On Mon, 01 Mar 2004 11:00:48 +0000, pete wrote:

A cast is required when converting from (const void *) to (void *).

This should, in all likelihood, simply not be done in the first place. :)

[Ben Pfaff]

rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:

ro**@zworg.com (Amarendra GODBOLE) wrote:

The linux manpage for memcpy(3) gives me the following prototype of
memcpy(3):
#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);

memcpy(arr, p, sizeof *p);

Someone tells me -- this is an incorrect usage, you either need to do
memcpy(arr, (char *)p, sizeof *p);
or
memcpy((void *)arr, (void *)p, sizeof *p);

That someone is wrong. Unlike, for example, C++, the C language does not
require the casts. IMO, this is a point where C is clearly superior.

As I read the C++ standard, C++ requires a cast to convert from
void * to pointer-to-object type, but not to convert from
pointer-to-object type to void *. I am willing to be corrected
on this point.
--
int main(void){char p[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv wxyz.\
\n",*q="kl BIcNBFr.NKEzjwCIxNJC";int i=sizeof p/2;char *strchr();int putchar(\
);while(*q){i+=strchr(p,*q++)-p;if(i>=(int)sizeof p)i-=sizeof p-1;putchar(p[i]\
);}return 0;}

[Peter Pichler]

"Richard Bos" <rl*@hoekstra-uitgeverij.nl> wrote in message
news:40**************@news.individual.net...

Unlike, for example, C++, the C language does not
require the casts. IMO, this is a point where C is clearly superior.

Another one is readability ;-)

[Michael Wojcik]

In article <pa****************************@lightspeed.bc.ca >, Kelsey Bjarnason <ke*****@lightspeed.bc.ca> writes:

On Mon, 01 Mar 2004 11:00:48 +0000, pete wrote:

A cast is required when converting from (const void *) to (void *).

This should, in all likelihood, simply not be done in the first place. :)

There are times when it is (IMO) appropriate. I often find myself
dealing with APIs supplied by another developer that are not const-
correct - that is, they don't declare object-pointer parameters to
data they do not change as const. When I wrap such a function in one
of my own, mine will be const-correct. At some point, then, I may
have to pass a pointer to a const object as a pointer to a non-const
object. That's going to require a const-removing cast somewhere.

(The alternatives that come to mind are copying the data into a new
area and passing a non-const pointer to it, and getting the API owner
to fix his API. The former is obviously less than optimal. The
latter is preferable but not always achievable in a reasonable
timeframe.)

--
Michael Wojcik mi************@microfocus.com

Be sure to push the button of the bottom, and push the button of the
settlement page indicated next only once, there is fear of the bottom
rhinoceros multiplex lesson money. -- Sukebe Net

[Amarendra GODBOLE]

Ben Pfaff <bl*@cs.stanford.edu> wrote in message:

Your informant is wrong. No such casts are necessary in C.

Thanks all of you. All the replies have made my stand strong, and I
can prove my point now. But this cannot be end without a small joke...

I wrote a code snippet for my colleague: (the ``someone'' in my
previous post.) :)

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

int main(void)
{
char arr[20];
typedef struct foo_ {
int i;
char c;
float f;
} foo;
foo *fptr;
foo *fptr1;

/* Okay, in real life we need to check the return value of
malloc() */
fptr = malloc(sizeof *fptr);
fptr->i = 21;
fptr->c = 'A';
fptr->f = 16.45;

memcpy(arr, fptr, sizeof *fptr);
fptr1 = (foo *)arr;

printf("Array contains %i, %c, %f\n", fptr1->i, fptr1->c,
fptr1->f);
free(fptr);

return 0;
}

I do get correct values printed out. Even after this, my colleague
told me that it has worked here because foo is a simple stucture, and
it might not work in complicated structures (!). Never heard that C --
makes a distinction between simple and complex structures !! ;)

Thanks once again.

Cheers,
Amarendra

--
Picture Perfect Engineering / GE Security / #include
<std$disclaimer.h>

[Martien Verbruggen]

On 1 Mar 2004 18:43:45 -0800,
Amarendra GODBOLE <ro**@zworg.com> wrote:

Ben Pfaff <bl*@cs.stanford.edu> wrote in message:

Your informant is wrong. No such casts are necessary in C.

I wrote a code snippet for my colleague: (the ``someone'' in my
previous post.) :) foo *fptr;
foo *fptr1; memcpy(arr, fptr, sizeof *fptr);
fptr1 = (foo *)arr;
You also don't need, and shouldn't use, this cast.
I do get correct values printed out. Even after this, my colleague
told me that it has worked here because foo is a simple stucture, and
it might not work in complicated structures (!). Never heard that C --
makes a distinction between simple and complex structures !! ;)

Your collegue is still wrong. If he means that you can't simply use
memcpy() to make a 'deep' copy of a structure that has pointers in iti
(which could be one interpretation of 'complicated' structures),
he/she is right, but that won't be fixed with a cast.

The point is simply that casts are not necessary in memcpy() (or
anywhere else where pointers need to be converted to void * or from
void *). The complexity of whatever is being pointed to does not
change that in any way. Maybe your collegue could explain what
"complicated structures" are?

Martien
--
|
Martien Verbruggen | Begin at the beginning and go on till you
Trading Post Australia | come to the end; then stop.
|

[CBFalconer]

Amarendra GODBOLE wrote:

Ben Pfaff <bl*@cs.stanford.edu> wrote in message:

Your informant is wrong. No such casts are necessary in C.

Thanks all of you. All the replies have made my stand strong, and I
can prove my point now. But this cannot be end without a small joke...

I wrote a code snippet for my colleague: (the ``someone'' in my
previous post.) :)

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

int main(void)
{
char arr[20];
typedef struct foo_ {
int i;
char c;
float f;
} foo;
foo *fptr;
foo *fptr1;

/* Okay, in real life we need to check the return value of
malloc() */
fptr = malloc(sizeof *fptr);
fptr->i = 21;
fptr->c = 'A';
fptr->f = 16.45;

memcpy(arr, fptr, sizeof *fptr);
fptr1 = (foo *)arr;

printf("Array contains %i, %c, %f\n", fptr1->i, fptr1->c,
fptr1->f);
free(fptr);

return 0;
}

I do get correct values printed out. Even after this, my colleague
told me that it has worked here because foo is a simple stucture, and
it might not work in complicated structures (!). Never heard that C --
makes a distinction between simple and complex structures !! ;)

Wrong answer. 'Working' here actually depends on the alignment of
arr, over which you have no direct control. There are several
illegalities in your code snippet, especially including the
assignment to fptr1 and the cast involved. Ugh.

--
Chuck F (cb********@yahoo.com) (cb********@worldnet.att.net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net> USE worldnet address!

[Christian Bau]

In article <40***************@yahoo.com>,
CBFalconer <cb********@yahoo.com> wrote:

Wrong answer. 'Working' here actually depends on the alignment of
arr, over which you have no direct control. There are several
illegalities in your code snippet, especially including the
assignment to fptr1 and the cast involved. Ugh.

Many people who are not deterred by the plain ugliness and the fact that
there is undefined behavior (which means even if it "works" today, it
can fail if you compile it again with the next compiler version, with an
optimising compiler, with a different compiler, on a different
architecture), might be deterred by the fact that using unaligned
pointer might easily make your code run fifty times slower than it
could.

[Amarendra GODBOLE]

> > memcpy(arr, fptr, sizeof *fptr);

fptr1 = (foo *)arr;

Wrong answer. 'Working' here actually depends on the alignment of
arr, over which you have no direct control. There are several
illegalities in your code snippet, especially including the
assignment to fptr1 and the cast involved. Ugh.

Hmmm...yes, right you are. How do I get the values back then ? Will
you kindly point out the other illegalities too ? Thanks in advance.

Cheers,
Amarendra

--
Be ashamed to die unless you have won some victory for humanity.
-Horace Mann

[pete]

Amarendra GODBOLE wrote:

memcpy(arr, fptr, sizeof *fptr);
fptr1 = (foo *)arr;

Wrong answer. 'Working' here actually depends on the alignment of
arr, over which you have no direct control. There are several
illegalities in your code snippet, especially including the
assignment to fptr1 and the cast involved. Ugh.

Hmmm...yes, right you are. How do I get the values back then ? Will
you kindly point out the other illegalities too ? Thanks in advance.

The size issue can be addressed by using the sizeof result
from the structure, to allocate the array.
The alignment issue can be addressed by a union,
as in K&R2 Section 8.7, Example-A Storage Allocator.

/* BEGIN memcast.c */

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

int main(void)
{
struct foo {
int i;
char c;
float f;
};
union {
char arr[sizeof(struct foo)];
struct foo align;
} align;
struct foo struct1;
struct foo *fptr1;

struct1.i = 21;
struct1.c = 'A';
struct1.f = 16.45f;
memcpy(align.arr, &struct1, sizeof struct1);
fptr1 = (struct foo *)align.arr;
printf("Array contains %i, %c, %f\n",
fptr1 -> i, fptr1 -> c, fptr1 -> f);
return 0;
}

/* END memcast.c */
--
pete