Perfect forwarding and the scope of temporary objects - c++

Question

In an attempt to realize perfect forwarding for the * operator I constructed the following example.
#include <string>
#include <iostream>
class A {
public:
std::string name;
A(const A& _other) : name(_other.name) {
std::cout << "Copy-Construct with name: " << name << std::endl;
}
A(A&& _other) : name(std::move(_other.name)) {
std::cout << "Move-Construct with name: " << name << std::endl;
}
A(std::string _name): name(_name) { }
};
A operator*(const A& _lhs, const A& _rhs) {
std::cout << "Start Operator Copy with: " << _lhs.name << " " << _rhs.name << std::endl;
A bla(_lhs.name+" "+_rhs.name);
return bla;
}
A&& operator*(A&& _lhs, const A& _rhs) {
std::cout << "Start Operator Move with: " << _lhs.name << " " << _rhs.name << std::endl;
_lhs.name += " "+_rhs.name;
return std::move(_lhs);
}
int main() {
A a("a");
A b("b");
A c("c");
A d("d");
A x = a*b*A("t1")*c*A("t2")*A("t3")*d;
std::cout << "Final result is: " << x.name << std::endl;
}
The result is as I hoped, in particular only one move constructor and no copy constructor is called.
Start Operator Copy with: a b
Start Operator Move with: a b t1
Start Operator Move with: a b t1 c
Start Operator Move with: a b t1 c t2
Start Operator Move with: a b t1 c t2 t3
Start Operator Move with: a b t1 c t2 t3 d
Move-Construct with name: a b t1 c t2 t3 d
Final result is: a b t1 c t2 t3 d
Now my question is: Is this leagal C++11 code? In particular can I rely on the fact that the first temporary object (contructed from a and b) leaves its scope at the semicolon and not before that? And is the construction, to return an object obtained as a move reference back as a move reference, legal at all?

Answer 1

A&& operator*(const A& _lhs, const A& _rhs) {
std::cout << "Start Operator Copy with: " << _lhs.name << " " << _rhs.name << std::endl;
A* bla = new A(_lhs.name+" "+_rhs.name);
return std::move(*bla);
}
This creates a dynamically allocated object, so the caller is responsible for deleting it. Your example fails to do that, so leaks memory. This is a terrible function. It should return by value instead, which will be faster because you don't allocate the object on the heap.
A&& operator*(A&& _lhs, const A& _rhs) {
std::cout << "Start Operator Move with: " << _lhs.name << " " << _rhs.name << std::endl;
_lhs.name += " "+_rhs.name;
return std::move(_lhs);
}
This doesn't lead to memory leaks, so isn't totally obviously wrong like the first one, but it's still wrong. If you call it with a temporary object it returns a reference to that same temporary, but that can lead to dangling references:
A&& c = A("a") * A("b");
The reference c is bound to the temporary created by A("a") but that does out of scope at the end of the statement. Any attempt to use c has undefined behaviour.
Both overloads should return by value.
You might also want an overload for the case where the left-hand side is an lvalue and the right-hand side is an rvalue, as that allows you to re-use the right-hand side object. And if you add that you also need an overload for the case where both operands are rvalues. Basically, look at how std::string defines operator+