Having recently done some development for iPhone, I've come to notice an interesting design pattern used a lot in the iPhone SDK, regarding object mutability.

It seems the typical approach there is to define an immutable class `NSFoo`, and then derive from it a mutable descendant `NSMutableFoo`. Generally, the `NSFoo` class defines data members, getters and read-only operations, and the derived `NSMutableFoo` adds on setters and mutating operations.

Being more familiar with C++, I couldn't help but notice that this seems to be a complete opposite to what I'd do when writing the same code in C++. While you certainly *could* take that approach, it seems to me that a more concise approach is to create a single `Foo` class, mark getters and read-only operations as `const` functions, and also implement the mutable operations and setters in the same class. You would then end up with a mutable class, but the types `Foo const*`, `Foo const&` etc all are effectively the immutable equivalent.

I guess my question is, does my take on the situation make sense? I understand why Objective-C does things differently, but are there any advantages to the two-class approach in C++ that I've missed? Or am I missing the point entirely?

Not an overly serious question - more for my own curiosity than anything else.