移动构造函数如何在C ++中工作？

Question

I have read many articles about move constructor (even on stack) but i didn't find anywhere an exact explanation about how this works (how is transfer pointer to a temporary object and saved if this temporary variable and its address will be destroy when meet ")" ).

Here is a simple example

#include <iostream>
#include <vector>
using namespace std;
class boVector {
private:
    int size;
public:
    boVector() {};
    boVector(const boVector& rhs) { cout << "copy Ctor." << endl; }
    boVector(boVector&& rhs) { cout << "move Ctor." << endl; }
};

void foo(boVector v) {}
boVector createBoVector() { return boVector(); }

int main()
{
    //copy
    boVector reausable = createBoVector();
    foo(reausable);
    //move
    foo(std::move(createBoVector()));
    return 0;
}

All say that a move Ctor is a shallow copy copy or just a pointer assignment. But how can i initiate my object with a pointer to a temporary object (when this object will be destroy my object will point to an unknown address and this is not valid from my point of view).

Is not right to initiate a variable with a pointer address that will no longer exist after he meet ")".

Please if can somebody explain me how looks this temporary variable in memory and how is possible to assigned the address of temporary object to my current one and this operation to be a valid one.

Answer 1

A "move constructor" is nothing magical - it is a constructor that takes an rvalue reference .

Rvalue references bind to temporary object, and have the "meaning" of something that's about to expire and that won't be accessed later on in the program: this enables developers to implement moves for resource-holding classes in terms of pointer swaps or similarly fast operations.

Your boVector class cannot really take any advantage from move semantics, as it just stores an int and doesn't hold any resource. Moving an int is as fast as copying one.

---

In the

foo(std::move(createBoVector()));

expression, std::move is redundant as createBoVector() is already an rvalue .

---

Consider:

foo(createBoVector());

This will invoke boVector(boVector&&) as it's a better match than boVector(const boVector&) .

The instance created by createBoVector() will live for the full duration of the expression - this means that the rvalue reference will be pointing to a valid object for the duration of boVector(boVector&&) .

Answer 2

All say that a move Ctor is a shallow copy copy or just a pointer assignment.

Not all say that, as it is not true. A move constructor is what you define it to be. In your example, your move ctor does something else entirely. The point of a move ctor - as opposed to a copy ctor - is that you know that the other object is about to be destroyed, so you can cannibalize, or move, its resources.

A move constructor may make a "shallow copy", although that term is colloquial rather than well-defined in C++. "Just a pointer assignment" - perhaps, possibly, sometimes.

But how can i initiate my object with a pointer to a temporary object (when this object will be destroy my object will point to an unknown address and this is not valid from my point of view).

You don't (usually) initialize an object of type T with a pointer of type T* , per se. You can assign my_t = *my_t_ptr , or if you know you can "cannibalize" the T which my_t_ptr is pointing to, since it will soon be deleted, then you can assign my_t = std::move(*my_t_ptr) .

Can you give me a more relevant example [of a meaningful difference between a move constructor and a copy constructor]...?

The "classical" example is when your T is constructed by allocating some space on the heap. When you copy-construct one T from another, you have no choice but to allocate a second stretch of memory; when you move-construct a T , you can :1. copy the pointer from the existing T to the T under construction. 2. set the existing T 's member pointer to nullptr . In this case you only ever use one T 's worth of stack space.