It is dangerous to use pointers or references to portions of a
temporary object. The compiler may very well delete the object before
you expect it to, leaving a pointer to garbage. The most common place
where this problem crops up is in classes like the libg++
String class, that define a conversion function to type
char * or const char *. However, any class that returns
a pointer to some internal structure is potentially subject to this
problem.
For example, a program may use a function strfunc that returns
String objects, and another function charfunc that
operates on pointers to char:
String strfunc (); void charfunc (const char *);
In this situation, it may seem natural to write `charfunc
(strfunc ());' based on the knowledge that class String has an
explicit conversion to char pointers. However, what really
happens is akin to `charfunc (strfunc ().convert ());',
where the convert method is a function to do the same data
conversion normally performed by a cast. Since the last use of the
temporary String object is the call to the conversion function,
the compiler may delete that object before actually calling
charfunc. The compiler has no way of knowing that deleting the
String object will invalidate the pointer. The pointer then
points to garbage, so that by the time charfunc is called, it
gets an invalid argument.
Code like this may run successfully under some other compilers, especially those that delete temporaries relatively late. However, the GNU C++ behavior is also standard-conformant, so if your program depends on late destruction of temporaries it is not portable.
If you think this is surprising, you should be aware that the ANSI C++ committee continues to debate the lifetime-of-temporaries problem.
For now, at least, the safe way to write such code is to give the temporary a name, which forces it to remain until the end of the scope of the name. For example:
String& tmp = strfunc (); charfunc (tmp);