Is it safe to return a passed-in temporary value and read from it in the same statement?

Question

I just wrote this without thinking too hard about it. It seems to work fine, but I'm not sure if it's strictly safe.

class Foo
{
    struct Buffer
    {
        char data [sizeof ("output will look like this XXXX YYYY ZZZZ")];
    };

    const char * print (const char * format = DEFUALT_FORMAT, Buffer && buf = Buffer ())
    {
        sort_of_sprintf_thing (format, buf .data, sizeof (buf.data), ...);
        return buf .data;
    }
};

std :: cout << Foo () .print ();

So I think the semantics are that the temporary Buffer will remain in existence until the whole cout statement completes. Is that right, or will it go out of scope before then, in which case this is UB?

Answer 1

Yes, your code is well-defined.

[class.temporary]

3 - [...] Temporary objects are destroyed as the last step in evaluating the full-expression (1.9) that (lexically) contains the point where they were created. [...]

[intro.execution]

11 - [ Note: The evaluation of a full-expression can include the evaluation of subexpressions that are not lexically part of the full-expression. For example, subexpressions involved in evaluating default arguments (8.3.6) are considered to be created in the expression that calls the function, not the expression that defines the default argument. — end note ]

That doesn't mean it's particularly good, though - it would be far too easy to bind the result of Foo().print() to a char const* variable, which would on the next full-expression become a dangling pointer.