How to have "factory function" return a non copyable object?

Question

Context

Trying to create some gzip archive with a different filename inside I wrote this following snippet of code.

#include <iostream>
#include <utility>

#include <boost/iostreams/filtering_stream.hpp>
#include <boost/iostreams/device/file.hpp>
#include <boost/iostreams/filter/gzip.hpp>

boost::iostreams::filtering_ostream&& makeGZipStream(const std::string& archiveName,
                                                     const std::string& fileName)
{
    boost::iostreams::filtering_ostream theGzipStream;

    boost::iostreams::gzip_params theGzipParams;

    theGzipParams.file_name = fileName;

    theGzipStream.push(boost::iostreams::gzip_compressor{theGzipParams});

    theGzipStream.push(boost::iostreams::file_sink{archiveName});

    return std::move(theGzipStream);
}

int main()
{
    boost::iostreams::filtering_ostream&& theGzipStream = makeGZipStream("archive.gz", "file");

    theGzipStream << "This is a test..." << std::endl;

    return 0;
}

Problem

This (as we may expect) produces a core dump because in makeGZipStream we try to return a local stack-allocated variable by (rvalue-)reference. But the copy was not an option in this case as boost::iostreams::filtering_ostream is non-copyable.

Questions

We can return a std::unique_ptr "by value" thanks to its move constructor (and the move should not even occur in C++17 thanks to copy-elision), why isn't it possible in this case ?
What are the good solutions there ?

Possible solutions

Putting everything in the same scope (what I was trying to avoid)
Wrapping your object in a unique_ptr (not so pretty)
Anything else ?

Notes

The compiler used was the quite old g++ (GCC) 4.9.3.

Just return and assign `boost::iostreams::filtering_ostream`s. You seem to be making it more complicated than it has to be. — François Andrieux, Jul 20 '18 at 14:50
@FrançoisAndrieux The type is non-copyable, `g++` complains with I try this option. — matovitch, Jul 20 '18 at 14:52
Undefined behavior - returning a reference to a local variable — SergeyA, Jul 20 '18 at 14:52
@matovitch If you use `return std::move(theGzipStream);` and it still complains, make sure your type has a move constructor. — François Andrieux, Jul 20 '18 at 14:52
@FrançoisAndrieux bad practice and not recommended (moving from local variables). — SergeyA, Jul 20 '18 at 14:53
@matovitch your question is factually incorrect. It works for `unique_ptr`s not because of copy elision, but because of move constructor — SergeyA, Jul 20 '18 at 14:54
@FrançoisAndrieux You're right, the error has to be with the missing move constructor. Unfortunately I am not free to use a more recent version of boost. — matovitch, Jul 20 '18 at 14:54
@matovitch Then your type is both non-copyable and non-movable. It can never be returned by value. The easiest workaround is probably to wrap it in a `unique_ptr`. — François Andrieux, Jul 20 '18 at 14:55
@SergeyA Yes, if you use `std::move` like I did, otherwise it's copy ellision. My mistake. :) — matovitch, Jul 20 '18 at 14:55
@matovitch, doesn't matter, it still semantically the same. Without move constructor, `unique_ptr` would not be returnable from function (excluding C++ 17 copy elision). — SergeyA, Jul 20 '18 at 14:57
@matovitch Well, maybe You are not compiling it with C++11 enabled? — bartop, Jul 20 '18 at 15:00

score 5 · Accepted Answer · answered Jul 20 '18 at 15:02

Just return by value and remove std::move() from return statement:

boost::iostreams::filtering_ostream makeGZipStream(const std::string& archiveName,
                                                     const std::string& fileName)
{
    ...
    return theGzipStream;
}

if it fails to compile due to missing move constructor, then you are out of luck and this type is not movable, so wrap it into std::unique_ptr and return that pointer by value (which is movable for sure).