c ++使用指针时的移动语义

Question

How do I use the move assignment operator when working with raw pointers.

Is there any other way than doing something like:

void Function(T* dest)
{
    T* src = LoadT();
    (*dest) = std::move(*src);
    delete src;
}

Answer 1

Your move is fine. The object pointed to by src will be moved into the object pointed to by dest.

About your updated code example, the version with Function:

If your LoadT() returns a raw pointer to an object allocated with new, that does not get stored somewhere else and later deleted, you will have a memory leak.

When you std::move something, you move the contents of that object, the object itself remains alive, only "empty"/in whatever state you leave it after moving.

If you return a pointer to an object that is owned by someone else and will be cleaned up somehow beyond the code that's seen here, you could make that explicit by changing your pointers to references - that way you will explicitly specify that: a) the pointers are guaranteed to not be null; b) that there should be no worries about deleting the object you get from LoadT, since a reference can't have ownership of that object.

Answer 2

Unless you reference the objects in a temporary variable you are out of luck. Technically (not sure if illegal) you are allowed to provide your own specialization of move in which you can hide that behavior. But at one point or another, you have to dereference those pointers.

Answer 3

You want to have the pointed-to-object s moved onto one another, then you are already doing that in the correct/standard/only way, that is de-reference the pointer and then move *src onto *dest .

---

That being said, you interface is semanticly 'problematic' . A pointer to a function is by convention taken to mean non-owning and optional. Ownership seems not to be the issue here, but optional is. Why use a pointer when you can use a reference ? and moreover why use a reference when you can just use return value ?

In effect you could simplify to:

T Function()
{
    return LoadT();
}

Then let users of the function decide how to best use T. If T is polymorphic you could return std::unique_ptr<T> instead.