Re: When may an [optimizing] C++ compiler omit object instantiations?
* Kai-Uwe Bux:
blargg wrote:
Victor Bazarov wrote:
John Lampe wrote:
[...]
int fooClass::barMethod(int i)
{
mutex_taker _mutex(g_mutex);
return i*2;
}
(Assuming the class 'mutex_taker' takes the mutex in its constructor
and releases it in its destructor).
What's preventing the compiler from optimizing the entire construction
of '_mutex' out? (disassembling a functionally equivalent piece of real
code shows the expected; ctor and dtor of 'mutex_taker' are placed
inline).
[...]
*Temporary objects* are explicitly allowed to
be optimized away. Automatic objects are not.
Just to be more explicit, even temporary objects with clear side-effects
in their constructor/destructor, like printing to cout, can be optimized.
Is that supposed to mean that
mutex_taker( g_mutex ), some_protected_expression;
is not guaranteed to acquire the mutex at the beginning of the full
expression and release it at the end? If so, I would love to have a
reference to the clause of the standard that is responsible.
?3.7.2/3 "If a named automatic object has initialization or a destructor with
side effects, it shall not be destroyed before the end of the block, nor shall
it be eliminated as an optimization even if it appears to be unused, except that
a class object or its copy may be eliminated as specified in 12.8", where the
reference to 12.8 is ?12.8/5 about elimination of temporary copy construction.
I.e. name that mutex and code is safe.
I'm not at all sure about the unnamed temporary, but given that the standard
explicitly addresses the issue for /named/ automatic objects, I think that the
unnamed ones possibly have lesser protection by the law...
Cheers & hth.,
- Alf
--
Due to hosting requirements I need visits to <url: http://alfps.izfree.com/>.
No ads, and there is some C++ stuff! :-) Just going there is good. Linking
to it is even better! Thanks in advance!