Why doesn't this memcpy work?

Question

So I have the following code, a simplified version of what I want to do. I have a class with a member variable that I want to set to potentially a variety of different data types, depending on the situation (i just made a random struct for this test). I keep getting seg faults on the memcpy function though, and I have no idea why.

 #include <cstdlib>
 #include <iostream>
 #include <assert.h>
 #include <string>
 #include <string.h>
 #include <stdio.h>
 using namespace std;

struct product
{
        int price;
        string name;
};


class object
{
public:
        void setData(void *ptr);
        void* data;
};


void object::setData(void *ptr)
{
        assert(ptr);
        memcpy(data, ptr, sizeof(ptr));
}


int main()
{
        product* bag;
        product ba;
        bag = &ba;
        bag->price = 5;
        bag->name = "bag";

        object test;
        test.setData(bag);

        cout<<test.data->name<<endl;

        return 0;
}

And even if you got the `sizeof` correct, you cannot use `memcpy` on non-POD types, such as your `product` class. — PaulMcKenzie, Jan 21 '16 at 17:06

score 5 · Answer 1 · answered Jan 21 '16 at 17:05

Your code has multiple issues, but a direct cause of SIGSEGV is following line: memcpy(data, ptr, sizeof(ptr)); which tries to copy a number of bytes into unallocated pointer data.

On a side note, it looks like you are trying to achieve polymorphism in C++ using completely inapproriate methods.

score 2 · Answer 2 · edited May 23 '17 at 10:28

Others have mentioned that the memcpy is not correct due to using sizeof(void*) as the number of bytes to copy. But changing the sizeof to an appropriate value will just have you hit the next stumbling block with using memcpy. You would probably encounter it as soon as you execute this line:

cout<<test.data->name<<endl

The reason is that data->name is more than likely corrupted, invalid, or if you did actually see a name printed, the string is in an unstable state.

Basically, using memcpy to set a struct to a certain value isn't going to work if the struct is not a POD type.

What is a POD type?

POD updates for C++ 11

Your product class has a member that is a non-POD type, namely std::string. You cannot simply overlay a std::string object with bytes of data from another std::string object (which is what that memcpy will be doing).

The same thing can be said for functions such as memset or any C oriented function that sets the bytes of what is pointed to with values. They cannot be used on non-POD types.

Unlike POD types, just doing a copy of bytes like that will corrupt the destination object. If that object contained, say a v-table, then you really would be ripping the destination object to shreds.

For non-POD types, use the proper C++ techniques, which include using assignment (data = ptr).

As funny as it is, `std::string` is **almost** POD. The only thing which prevents it from being POD is different access control, but this is unlikely to cause any problems with `memcpy`. — SergeyA, Jan 21 '16 at 17:27
Sorry, had to downvote for referring to outdated POD definition. — SergeyA, Jan 21 '16 at 17:30
Having a non-trivial destructor also prevents a `std::string` from being "almost POD". — PaulMcKenzie, Jan 21 '16 at 17:38

score 0 · Answer 3 · answered Jan 21 '16 at 17:15

0

Also I suppose it could be problem here

 cout<<test.data->name<<endl;

case data is void pointer so you need cast here

 cout<<static_cast<product *>(test.data)->name<<endl;

answered Jan 21 '16 at 17:15

segevara

610
1
7
18

score 0 · Answer 4 · answered Jul 28 '22 at 20:29

I know this is an old post, but I don't like any of the answers, so for future readers.

When you cast an object to a void*, you loss the type information associated with it. That is why you can't use sizeof with a void* ptr. (This is probably also why memcpy doesn't do it this way). I think what you need here is to write a Template class. Then the code will know the type and the code should work.

template<class T>
class object
{
public:
        void setData(T *ptr);
        T* data;
};


void object::setData(T *ptr)
{
        assert(ptr);
        memcpy(data, ptr, sizeof(ptr));
}

Why doesn't this memcpy work?

4 Answers4