Prevent object copy on return

Question

I have this:

struct Point
{
    size_t x;
    size_t y;
    ~Point()
    {
        std::cout << "Destro" << "\n";
    }
};

const Point& getPoint()
{
    return { 100, 120 };
}
int main()
{
    Point p = getPoint();
    std::cout << "Exit" << "\n";
}

and the result is

Destro
Exit
Destro

I'm basically trying to make the getPoint method not have to copy the Point class. Here is what's happening so far:

Point Created
Point copied to the result
Point destroyed

How can I make it so that Point is only destroyed once?

You're returning a reference to a local and later trying to read from that reference, so the behavior of your program is undefined. — Miles Budnek, Nov 03 '20 at 21:57

NathanOliver · Accepted Answer · 2020-11-03T22:03:33.900

6

You need to return by value instead of reference. Using

Point getPoint()
{
    return { 100, 120 };
}

Allows C++17's guaranteed copy elision to kick in which causes Point p = getPoint(); to act as if it was Point p{ 100, 120 };

Side note: Never, Never, Never, return a function local object by reference. That object will be destroyed at the end of the function leaving you with a dangling reference and using that is undefined behavior.

edited Nov 03 '20 at 22:03

answered Nov 03 '20 at 21:59

NathanOliver

171,901
28
288
402

But what about this: – ManUser123 Nov 03 '20 at 22:00
Say you initialize Point as Point p; p.x = 100; return p; – ManUser123 Nov 03 '20 at 22:00
I tried that out and it copies it in that scenario. Is that inevitable? – ManUser123 Nov 03 '20 at 22:01
@ManUser123 In that case, you have a named object so either NRVO will apply, which is not guarnteed, or you'll get a move/copy. – NathanOliver Nov 03 '20 at 22:02
That one depends on how smart the compiler is. A compiler's allowed to do anything it wants with your code so long at you won't be able to see the difference. See the [As-if Rule](https://en.cppreference.com/w/cpp/language/as_if) – user4581301 Nov 03 '20 at 22:02

score 0 · Answer 2 · answered Nov 03 '20 at 22:24

Here's an example of what it looks like you're trying to achieve...

#include <iostream>

struct Point {
    size_t x;
    size_t y;
    ~Point() { std::cout << "Destructor called\n"; }

    // Explicitly deleting the Copy Constructor only to illustrate a point.
    Point(const Point& other) = delete;
};

const Point makePoint(size_t a, size_t b) {
    return Point{ a, b };
}

int main() {
    Point a = makePoint(3, 5);
    std::cout << a.x << ',' << a.y << '\n';
}

Output:

3,5
Destructor called

If you noticed, I explicitly deleted the Copy Constructor and left the Assignment Operator undeclared so that it will use the default. The struct is still using the default constructor and I didn't define a User Defined constructor.

In makePoint() I added two parameters/arguments to the function so that the user can set any values to the Point object. The function is returning a const Type object. The return statement in the function is using:

return Point{a, b};

instead of

return Point(a, b);

The latter will fail to compile because there is no user-defined constructor. However, the former works because I'm using brace-initialization. This will allow construction of the object on return instead of creating a temporary on the stack frame of the function and copying that temporary as its return value. This is a form of Copy Elision.

Now, if you want to be able to copy this object, you can remove the deleted constructor and allow the class to use its default copy constructor. The semantics of the Copy Elision will still work.

This will have the same exact results. I showed the explicit deletion of the Copy Constructor to initially prevent any Copying semantics. Then explained how the code works so you can take the original above and remove the line for the deleted copy constructor and it will still work the same:

struct Point {
    size_t x;
    size_t y;
    ~Point() { std::cout << "Destructor called\n"; }
};

const Point makePoint(size_t a, size_t b) {
    return Point{ a, b };
}

The functionality or behind the scenes magic is happening within the function makePoint() and that it returns a const object and uses brace-initialization of the class.

Prevent object copy on return

2 Answers2