Returning a Static Local Reference

Question

Suppose I have a function that will return a large data structure, with the intention that the caller will immediately copy the return value:

Large large()
{
    return Large();
}

Now suppose I do not want to rely on any kind of compiler optimizations such as return value optimization etc. Also suppose that I cannot rely on the C++11 move constructor. I would like to gather some opinions on the "correctness" of the following code:

const Large& large()
{
    static Large large;
    large = Large();
    return large;
}

It should work as intended, but is it poor style to return a reference to a static local even if it is const qualified?

Answer 1

I don't think there's any issue with doing this. So long as this code base is, and forever will be, single threaded.

Do this on a multithreaded piece of code, and you might never be able to figure out why your data are occasionally being randomly corrupted.

Answer 2

It all depends on what should work as expected means. In this case all callers will share references to the exact same variable. Also note that if callers will copy, then you are effectively disabling RVO (Return Value Optimization), which will work in all current compilers ^[*].

I would stay away from that approach as much as possible, it is not idiomatic and will probably cause confusion in many cases.

^[*]The calling convention in all compilers I know of determines that a function that returns a large (i.e. does not fit a register) variable receives a hidden pointer to the location in which the caller has allocated the space for the variable. That is, the optization is forced by the calling convention.