Thread: memcpy

Does anyone know what the "rules" are for using memcpy for non-standard data types?

I ran into problems using combinations of memcpy with the = operator when using AnsiString.

e.g.:

Code:

AnsiString dest;
AnsiString src1 ="abcdefghijklmnopqrstuvwxyz";
AnsiString src2 ="0123456789";
memcpy(&dest,&src1,sizeof(dest));
memcpy(&dest,&src2,sizeof(dest));

works fine.

but something like:

Code:

AnsiString dest;
AnsiString src1 ="abcdefghijklmnopqrstuvwxyz";
AnsiString src2 ="0123456789";
memcpy(&dest,&src1,sizeof(dest));
dest = src2;
memcpy(&dest,&src1,sizeof(dest));

produces unpredictable results.

However, using char * instead of AnsiString works beautifully.

I have used AnsiString extensively, and while it's not such a big deal to change all of my instances of the class to std::string or char *, the Borland app framework I work with uses AnsiString exclusively, so i would have to have a "mirror" property and setter function every time i want to set any of those instances of Ansistring.

can someone explain to me what is wrong here, and how i can avoid it, short of always using char *?

i'm not sure i get what you're saying. can you elaborate?

how could you not write to one?

String literals do not live in memory you own. In the code

Code:

char *trap = "This is a trap."

any attempt to write to trap will immediately fail, in flames if the chipset supports it. You can't do

Code:

memcpy(trap, buf);

later on.

Edit: I don't know anything about AnsiString, but I would suspect a similar fate would befall you.

Using memcpy() on non-POD data types is wrong. Period. Use std::copy().

Originally Posted by Salem

Or use the provided class member assignment operator.
As in
dest = src;

Code:

struct foo {
  int a;
  int *b;
};

Imagine b is allocated to point to a block of memory. If you simply memcpy the pointer, you do NOTHING with the memory being pointed at. Hence everything goes wrong.

Code:

typedef struct foo {
  int a;
  int *b;
}s;
foo *f = new foo();
f->b = new int(1);
f->a = 0;
memcpy(&f->a,f->b,sizeof(f->a));

this works

Originally Posted by Salem

But that isn't what you asked, you asked how to do

foo a, b;
memcpy( &a, &b, sizeof(foo) );

that appears to work also.

Code:

       
int *val = new int(1);
typedef struct foo
{
        int a;
        int *b;
}s;
foo f1;
f1.a = 0;
f1.b = val;
foo f2;
memcpy(&f2,&f1,sizeof(f1));

*f2.b == 1

that appears to work also.

If by work you mean: "Changing '*f1.b' also changes '*f2.b'." then sure.

Soma

Originally Posted by phantomotap

If by work you mean: "Changing '*f1.b' also changes '*f2.b'." then sure.

Soma

i'm utterly confused. what am i missing here?

it copies the pointer in f1 to the pointer in f2 so they both point to the same location. what else would you want it to do in that instance?

Dorking around with memcpy() when a perfectly good assignment operator is available is... inexplicable.