Re: What is the idiom for cached calculations preserving const-ness?

Thanks for everyones comments and the education on volatile.

In the case of this class, it is perfectly reasonable to never return
any non-const references to internal data. If they wanted to change
the matrix, they could call a special function and it would invalidate
the inverse.

I hadn't thought about the race conditions, but would also hate to
have normal access to the inverse require a mutex around it. How
about this strategy (assuming mutable shared_ptr for the inverse)

boost::mutex inverse_mutex;

   const M& inverse() const
   {
     if (!my_inverse)
     {
       boost::mutex::scoped_lock lock(inverse_mutex)
       my_inverse = shared_ptr(new M(my_r, my_c));
       my_inverse.compute_inverse(my_data);
     }
     return *my_inverse;
   }

This way, the locking would occur precalculation. If two threads got
into the inner "if", then the calculation would occur twice, but that
seems reasonable. One criticism is that this would be a global block
on the calculation of the inverse for ALL instances of M. But this
also seems reasonable to me since this is just a caching strategy.

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]