temporary

Possible Duplicate: C++: Life span of temporary arguments? It is said that temporary variables are destroyed as the last step in evaluating the full-expression, e.g. bar( foo().c_str() ); temporary pointer lives until bar returns, but what for the baz( bar( foo().c_str() ) ); is it still lives until bar returns, or baz return means full-expression end here, compilers I checked destruct objects after baz returns, but can I rely on that? Temporaries life until the end of the full expression in which they are created. A "full expression" is an expression that's not a sub-expression of another

After reading this article on Herb Sutter's blog, I experimented a bit and ran into something that puzzles me. I am using Visual C++ 2005, but I would be surprised if this was implementation dependent. Here is my code: #include <iostream> using namespace std; struct Base { //Base() {} ~Base() { cout << "~Base()" << endl; } }; int main() { const Base & f = Base(); } When run, it displays " ~Base() " twice ... But if I un-comment the constructor, it displays it only once ! Does anyone have an explanation for this? This IS implementation dependent. The standard allows a copy to occur when binding

The code is as follows: #include <iostream> using namespace std; class A { }; A rtByValue() { return A(); } void passByRef(A &aRef) { // do nothing } int main() { A aa; rtByValue() = aa; // compile without errors passByRef(rtByValue()); // compile with error return 0; } The g++ compiler gives the following error: d.cpp: In function ‘int main()’: d.cpp:19:23: error: invalid initialization of non-const reference of type ‘A&’ from an rvalue of type ‘A’ d.cpp:12:6: error: in passing argument 1 of ‘void passByRef(A&)’ It says that I can't pass an rvalue as an argument of a non-const reference, but

I need to write a class whose constructor takes a constant reference to a object and stores it locally. In order to avoid most common mistakes I can foresee, I'd like to only accept references to non-temporary (ie: references to lvalues). How can I write a function that takes constant references to non-temporary only? Of course even a non-temporary could go out of scope and thus break my class behavior, but I believe that by disallowing temporary references I will avoid most mistakes. If you are going to store a reference and need to use it after the constructor has completed, it's probably

Consider the following code: #include <sstream> #include <iostream> class Foo : public std::stringstream { public: ~Foo() { std::cout << str(); } }; int main() { Foo foo; foo << "Test1" << std::endl; Foo() << "Test2" << std::endl; return 0; } When I execute this, it gives me: 004177FC Test1 I do not understand why the second example gives me gibberish. The temporary should live until the entire expression is evaluated, so why does it not behave the same as the first example? I tested it. I can guess that operator<< cannot bind a temporary to a non-const reference, so any externally defined

I know that the code written below is illegal void doSomething(std::string *s){} int main() { doSomething(&std::string("Hello World")); return 0; } The reason is that we are not allowed to take the address of a temporary object. But my question is WHY? Let us consider the following code class empty{}; int main() { empty x = empty(); //most compilers would elide the temporary return 0; } The accepted answer here mentions "usually the compiler consider the temporary and the copy constructed as two objects that are located in the exact same location of memory and avoid the copy." According to the