How to pass the ownership of an object to the outside of the function

Question

Is there any method that can pass the ownership of an object created in the function on the stack memory to the outside of the function without using copy construction?

Usually, compiler will automatically call destruction to the object on the stack of a function. Therefore, if we want to create an object of a class(maybe with some specific parameters), how can we avoid wasting lots of resources copying from temp objects?

Here is one common case:

while(...){
    vectors.push_back(createObject( parameter ));
}

So when we want to create objects in a iteration with some parameters, and push them into a vector, normal value passed way will take a lot of time copying objects. I don't want to use pointer and new objects on the heap memory as user are likely to forget delete them and consequently cause memory leak.

Well, smart pointer maybe a solution. But..less elegent, I think. hhhh

Is there any way of applying rvalue reference and move semantics to solve this problem?

Answer 1

Typically, returning an object by value will not copy the object, as the compiler should do a (named) return value optimization and thereby elide the copy.

With this optimization, the space for the returned object is allocated from the calling context (outer stack frame) and the object is constructed directly there.

In your example, the compiler will allocate space for the object in the context where createObject() is called. As this context is an (unnamed) parameter to the std::vector<T>.push_back() member function, this works as an rvalue reference, so the push_back() by-value will consume this object by moving (instead of copying) it into the vector. This is possible since if the generated objects are movable. Otherwise, a copy will occur.

In sum, each object will be created and then moved (if moveable) into the vector.

Here is a sample code that shows this in more detail:

#include <iostream>
#include <string>
#include <vector>

using Params = std::vector<std::string>;

class Object
{
public:
    Object() = default;
    Object(const std::string& s) : s_{s}
    {
        std::cout << "ctor: " << s_ << std::endl;
    }
    ~Object()
    {
        std::cout << "dtor: " << s_ << std::endl;
    }

    // Explicitly no copy constructor!
    Object(const Object& other) = delete;

    Object(Object&& other)
    {
        std::swap(s_, other.s_);
        std::cout << "move: traded '" << s_ << "' for '" << other.s_ << "'" << std::endl;
    }

    Object& operator=(Object other)
    {
        std::swap(s_, other.s_);
        std::cout << "assign: " << s_ << std::endl;
        return *this;
    }

private:
    std::string s_;
};


using Objects = std::vector<Object>;

Object createObject(const std::string& s)
{
    Object o{s};
    return o;
}

int main ()
{
    Objects v;
    v.reserve(4);  // avoid moves, if initial capacity is too small
    std::cout << "capacity(v): " << v.capacity() << std::endl;

    Params ps = { "a", "bb", "ccc", "dddd" };

    for (auto p : ps) {
        v.push_back(createObject(p));
    }

    return 0;
}

Note that the class Object explicitly forbids copying. But for this to work, the move constructur must be available.

A detailed summary on when copy elision can (or will) happen is available here.