我可以删除使用 memcpy() 复制的 class 指针吗？

Question

Is the following snippet of code valid?

class Foo
{
public:
    int a;
    SomeClass* pb;

    Foo() {...}
    Foo(const Foo& rhs)
    {
         this->a = rhs.a;
         memcpy(this->pb, rhs.pb, sizeof(SomeClass));
    }
    ~Request()
    {
        delete this->pb; // Suppose pb is a result of copy constructor,
                         // Is this valid or is there a better way?
    }
};

Answer 1

You can't copy classes using memcpy . And memcpy is just copying memory, not allocating anything.

Answer 2

You haven't actually allocated anything for pb . If you allocate it with new , then using delete in the destructor is perfectly valid.

But why oh why are you doing a memcpy ? You should be using the copy constructor of the class and letting it copy itself in the appropriate fashion. The only time a memcpy would be remotely acceptable is when the class is a simple struct of POD types.

Answer 3

It's valid, as in it will compile. But it is stricken with errors. You never allocated any memory, so you'd need to do that first. But there is absolutely no reason to use memcpy, and in most cases, it does the wrong thing. Just do this:

Foo(const Foo& rhs)
    :a(rhs.a),
     pb(new SomeClass(*rhs.pb))
{    
}

Or better yet, use a smart pointer, and you don't have to worry about deleting. Or better yet, don't use a pointer at all if you retain sole ownership of the object.

Answer 4

This code snippet is wrong because you can't call delete without calling to new for allocation of memory.

Also your memcpy call can cause segmentation fault in most cases, because you are copying to unintialized pointer. You should allocate memort for SomeClass pointer before calling to memcpy .

Answer 5

Using memcpy with anything other than POD structures/objects ("plain old data"--things with no non-default constructors or destructors, and with virtual methods) is a recipe for disaster. If you fix your program so that you're using memcpy to copy a POD structure which contains an "ordinary" pointer to a class item, any pointers copied as part of that structure must be handled the same as pointers copied via other means. Exactly one copy (or the original) of any such pointer must be "deleted"--no more and no less. If you copy the pointer and abandon the original without calling "delete" on it, you should then call "delete" on exactly one copy.

In general, one should avoid using memcpy in C++; in C, structures never had any "hidden" information which could be left in an inconsistent state by memcpy, but in C++ they often do (with the exception of POD structures). Although C++ is designed to be mostly compatible with C, the fact that something is legal in C does not mean that it is proper in C++.

Answer 6

You haven't allocated memory for that pointer using new , so you absolutely shouldn't be using delete on it. memcpy isn't allocating any memory for you.

Specifically, the only pointers you should be invoking delete on are pointers that have previously been returned by new , or a null pointer. To use delete on any other pointer is undefined behaviour, according to the C++03 standard, 3.7.3.2/3-4.

The value of the first argument supplied to one of the deallocation functions provided in the standard library may be a null pointer value; if so, the call to the deallocation function has no effect. Otherwise, the value supplied to operator delete(void*) in the standard library shall be one of the values returned by a previous invocation of either operator new(size_t) or operator new(size_t, const std::nothrow_t&)

...[snip]...

The effect of using an invalid pointer value (including passing it to a deallocation function) is undefined.)