默认移动构造

Question

The book The C++ Programming Language has this example about default operations. My question focuses on default move operation.

struct S {
    std::string a;
    int b;
};

S f(S arg) {
    S s0{};
    S s1(s0); //s1 {s0}; in the book
    s1 = arg;
    return s1;
}

After that it says:

The copy construction of s1 copies s0.a and s0.b. The return of s1 moves s1.a and s1.b, leaving s1.a as the empty string and s1.b unchanged. Note that the value of a moved-from object of a built-in type is unchanged. That's the simplest and fastest thing for the compiler to do.

I think this means if I write:

S s3{"tool",42};
f(s3);

Since the value of s1 is moved, s1.a will go back to "" and s1.b is unchanged? Then when f() finishes executing, s1 will be destroyed? I am trying to find a way to test my guess but I can't find a way to know the values of s1 after the function executes because it's of course local. I wrote a destructor just to find the values before they get destroyed.

~S() {
    std::cout << a << " " << b << '\n';
}

The outputs are:

0 //values of s0?
tool 42
tool 42
tool 42

It seems my guess is totally wrong and I totally don't understand the text. Can anyone explain the text in the quote clearer?

Answer 1

s1.a will go back to ""

Maybe. From the specification of the move constructor, it "is left in a valid state with an unspecified value." Typically, if the string is using a dynamically allocated array, and both strings use compatible allocators, then the move will transfer ownership of the array, leaving the old string empty. But if the string uses "short string optimisation", where short strings are stored inside the string object itself to save the cost of dynamic memory allocation, then it would be faster to leave the old string unchanged.

and s1.b is unchanged

Yes. Primitive types are never modified when assigned from.

Then when f() finishes executing, s1 will be destroyed?

Probably not. The optimisation of move elision (sometimes called "return value optimisation") is probably used here, unless you have a very primitive compiler or deliberately disable the optimisation. s1 will be created in the caller's stack frame, so that no work is needed to return it.

I can't find a way to know the values of s1 after the function executes

No, there's no way to examine the object after the return, since it no longer exists. If you want to see the effect of moving, you could move to a new local variable

S s2 = std::move(s1);

and examine s1 afterwards. Or you could write your own move constructor

S(S && other) : a(std::move(other.a)), b(b) {
    std::cout << other.a << '\n';
}

but, as noted above, this probably won't be used for the function return value.

Answer 2

First of all, by defining destructor you disabled the implicit move constructor. You have to add to your code:

S(const S&) = default;
S(S&&) = default;
S& operator=(const S&) = default;
S& operator=(S&&) = default; // not required here but should be added for completeness

Then, anyway RVO comes into play. As noted in other answers, the compiler is allowed to elide calls to copy and move constructors. In GCC and clang you can disable this by adding -fno-elide-constructors compiler option. After that you'll get this output:

 42 // moved s1 (this can theoretically be different, because the value of s1.a is unspecified)
 0  // s0
tool 42 // arg
tool 42 // return value of f()
tool 42 // s3

Demo