Why function in c++ can return stack values

This is an example of copy-elision, specifically RVO (return value optimization). It allows you to avoid the performance penalty of returning an object.

I've worked with a lot of people who were unaware of RVO and wrote stuff like:

void get_stuff(std::vector<int>& foo /*and input params*/) { // add a whole lot of integers into foo. } 

because they thought this would be cheaper (by avoiding a copy) than:

void get_stuff(/*input params*/){ std::vector foo; // populate foo. return foo; } 

This leads to unnecessarily verbose, and often difficult to read code. It's quintessential premature optimization -- a mistake you won't be making, since you now know about RVO!

Returning the function result by value is one of the places, where the compiler is allowed to elide a copy as an optimization and thus translates your code to the moral equivalent of this :

void f(uint8_t* memory) { new(memory) C; // create object reserved memory location cout << (size_t)memory << endl; } int main() { alignas(alignof(C)) uint8_t value[sizeof(C)]; //<- reserve properly aligned raw storage of appropriate size on the stack f(value); cout << (size_t)&value[0] << endl; } 

This optimization technique is called NRVO (named return value optimization) and is actually a pretty natural consequence of most calling conventions which specify that - for values that can't be returned via a register - the returned value is put at an address that is specified by the caller anyway.

I'm not sure whether this is actually RVO. An equally valid hypothesis is that the storage of both ret and value is on the implementation's stack, and that they share the same stack slot because their lifetimes are effectively non-overlapping. There might have been an intermediary.