temporary-objects

This question already has an answer here: stringstream, string, and char* conversion confusion 5 answers EDIT : Thanks to everyone who pointed out the problem, and that it was discussed on Stack Overflow. I cast the last close vote myself. A related question: neither CPP Reference on ostringstream or ostringstream::str state its a temporary. How did so many people know? Or is there different documentation I should have consulted? I'm having a lot of trouble with memory errors under Debian 7.3 (x64) with GCC 4.7.2, -std=c++11 and std::ostringstream . Its leading to bizaare results like https:/

I thought references only extend the lifetime of temporaries to the lifetime of the reference itself, but the output of the following snippet seems contradictory: #include <iostream> struct X{ ~X(){ std::cout << "Goodbye, cruel world!\n"; } }; X const& f(X const& x = X()){ std::cout << "Inside f()\n"; return x; } void g(X const& x){ std::cout << "Inside g()\n"; } int main(){ g(f()); } Live example. Output: Inside f() Inside g() Goodbye, cruel world! So it seems the temporary is destroyed after g() is called... what gives? The standard handles this in a special case in §12.2 [class.temporary] :

Given the following code: #include <iostream> struct implicit_t { implicit_t(int x) : x_m(x) { std::cout << "ctor" << std::endl; } ~implicit_t() { std::cout << "dtor" << std::endl; } int x_m; }; std::ostream& operator<<(std::ostream& s, const implicit_t& x) { return s << x.x_m; } const implicit_t& f(const implicit_t& x) { return x; } int main() { std::cout << f(42) << std::endl; return 0; } I get the following output: ctor 42 dtor While I know this is correct, I'm not certain why . Is there anyone with stdc++ knowledge who can explain it to me? Temporary objects are destroyed as the last step

IMO temporary objects are stored in dynamic (heap) memory, but I'm not sure. Can you please confirm or deny my thoughts? The standard does not mandate any memory area (heap/stack) for them, but they are just like local variables "automatic storage", that is at the end of the expression (or longer when bound to a ref-to-const) they are destructed. Most implementations will store them on the stack just like local variables. edit: As James Kanze pointed out: In the case the lifetime of a temporary is extended via a ref-to-const, its store location is on most implementations somewhat determined by