Hello,
I'd like to write a builder-like API to construct an object that re-uses
the memory at each construction stage, for example
const Point point = Point(x, y)
.scaled(scale1)
.translated(dx1, dy1)
.scaled(scale2)
.translated(dx2, dy2);
should be equivalent to writing something like
Point point(x, y);
point.scale(scale1);
point.translate(dx1, dy1);
point.scale(scale2);
point.translate(dx2, dy2);
This is primarily for personal code stylistic preferences, but it can
also sometimes lead to slightly nicer code.
However, the issue with the former API design is that it's not quite the
same as the latter design because extra Point objects are created with
it, see https://godbolt.org/z/xc5E3dbjs. Ideally, Point(x, y) would be
constructed in foo right away, and then .translated() + .scaled() would
operate with foo's memory, but it looks like it's not the case. I'm not
entirely sure if it's a GCC or a C++ restriction (this is copy elision
and move semantics but cranked to the maximum; at quick glance, I see
nothing that forbids it but I also don't see anything that explicitly
says such cases are supported) but I wonder whether GCC doesn't see that
Point(x, y) can be constructed in foo due to the transform call chain
and whether such optimizations are possible after all.
Regards,
Vlad
