By the Way. GetObject() returns an object, it's type was MyClass just not a pointer.

Never cast non-pointers to pointers. If the variable being returned is just an object, you need to first get that object:

MyClass myClass = GetObject();

Then you can get the address to that object, and assign it to a pointer.

MyClass *myPtr = &myClass;

...but you must be confident that 'myClass' lasts just as long as 'myPtr', or 'myPtr' will be accessing invalid information.
As soon as 'myClass' goes out of scope, the memory that 'myPtr' points to gets destroyed, but will sometimes appear to work under certain circumstances before biting you unexpectedly later.

With that understanding, you might see why this won't work:

MyClass *myPtr = &GetObject(); //Problem!

The value returned by GetObject() will only last until the end of that statement (the semicolon), which is why it needs to be copied into a real object, and not just a pointer or reference.

I think this post can be deleted safely.

Our posts and threads are preserved so others can learn from our mistakes as much as from our successes.

EDIT2: Ok, I'm guessing storing the copy in a variable forces it to stay alive while the variable is in scope rather than taking the address of a temporary, so there is a difference. Beer - the cause of (and solution to) all of life's problems - Homer Simpson

Yep. Although, to clarify, it doesn't "force it (the temporary) to stay alive", it creates a copy of the temporary, and the copy lasts the lifetime of the scope the copy is in. Same result though - referencing the temporary is invalid (because it instantly goes out of scope), referencing a copy of the temporary is valid as long as the copy still exists (which is until the copy goes out of scope).

Though, compiler optimizations will almost certainly optimize the copy entirely out of existence (RVO), so there is zero performance hit.

Hmm, depends if GetObject returns a temporary object or not. GetObject could return a global, static class member object or something created on the heap. All of those will live on after GetObject returns. That may not be a very good design choice though ;)

EDIT: Scratch that, if it returns an object it returns a copy. It still has an address though, there is no difference between

MyClass myClass = GetObject();

MyClass* pMyClass = &myClass;

and

MyClass* pMyClass = &GetObject();

as far as I can tell (on beer #7)

EDIT2: Ok, I'm guessing storing the copy in a variable forces it to stay alive while the variable is in scope rather than taking the address of a temporary, so there is a difference. Beer - the cause of (and solution to) all of life's problems - Homer Simpson

The first one creates a copy. The second one is wrong. A third option is this:

const MyClass & pMyClass = GetObject();
const MyClass* pMyClass = &myClass;

Here using a const reference extends the life of the temporary without a copy, but the value is const.

A third option is this:

const MyClass & pMyClass = GetObject();
const MyClass* pMyClass = &myClass;

Here using a const reference extends the life of the temporary without a copy, but the value is const.