Pimpl idiom without dynamic memory allocation

Hello!

I have just discovered a way to use the private implementation idiom
(pimpl), without the overhead of dynamic memory allocation. For those of
you who don't know what this is, Wikipedia has a nice article you can
read. Anyway, I discovered that if you make all members in the
implementation class mutable, you can in fact use this idiom without any
"unnecessary" memory allocation. Here's a minimal example of the method:

// In the header of your class called Line

#include <string>

class Line
{
public:

   Line(const std::string& name);
   const std::string& GetName() const;
   void SetName(const std::string& s);

private:

   // Private implementation idiom:
   // all member variables are hidden in this class
   class LineImpl;
   const LineImpl& m_pimpl; // normally a non-const pointer
};

// and in your implementation file:

#include "Line.h"

// Here we define the class with the member variables
class Line::LineImpl
{
public:

   LineImpl(const std::string& s) : m_s(s) {}
   // all methods need to be const here
   const std::string& GetName() const { return m_s; }
   void SetName(const std::string& s) const { m_s = s; }

private:

   mutable std::string m_s; // the trick! all members are mutable
};

// create the pimpl instance without using new
Line::Line(const std::string& s) : m_pimpl(LineImpl(s)) {}

// forward all member functions to the private implementation
const std::string& Line::GetName() const
{
   return m_pimpl.GetName();
}

void Line::SetName(const std::string& s)
{
   m_pimpl.SetName(s);
}

Ok experts, what do you all think? This method sacrifies
const-correctness for some extra speed. Is it worth it?

--
Daniel