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

I have a class that has a fairly expensive operation that the library
user may or may not need. SOmething like this;

....

However, they may not use the matrix so I wanted to cache the result.
so I ended up doing something like this:

class my_class
{
  matrix m_;
  shared_ptr<matrix> p_m_inverse_;

public:
 my_class(const matrix& m) : m_(m) {} //Calling some type of matrix
inverse

//Accessors
const matrix& matrix() const
{
  return m_;

}

const matrix& matrix_inverse() const
{
  if(!p_m_inverse_) //If not construted
  {
    p_m_inverse_ = shared_ptr<matrix>(new matrix(m_.size1(), m.size2
()); //Allocate of same siz
   *m_m_inverse = inverse(m_);
  }
 return *p_m_inverse_;

}
};

Now, of course this doesn't quite work since the const of the accessor
function doesn't allow modification of p_m_inverse. However, I really
need this function to be const because it makes sense semantically and
I pass around const& to this object all over the place.
The only solution I could find was to static_cast "this"