How to have const members in stl container values in C++?

Question

I like to make my C++ member variables const if they should not be changed once the object is constructed, however, sometimes they need to be modified by STL. For example, if I have a vector of my class with const members and I try to swap two elements in the vector, STL tries to use the default generated operator=() and fails because of the const member variables.

I feel like the operator=() is like a constructor in that the whole object is being created and thus would like some way to allow operator=() while still having my const member variables.

Is there anyway to do this in C++03? If not, what about in C++11, perhaps in-place construction is for this?

class Foo {
  const int _id;

  static int _generate_unique_id();

public:
  Foo()
    : _id(_generate_unique_id()) {
  }
};

vector<Foo> foo_vector;

// Fill foo_vector with several entries:
//   [...]

// Try to swap the first and second elements of the vector:
swap(*foo_vector.begin(), *(foo_vector.begin() + 1));
// The above fails to compile due to const member variable _id
// prohibits us from using the default assignment operator.

Answer 1

const on members doesn't just prevent the programmer from modifying the value of the member during its lifetime; it also enables compiler optimisations by specifying that attempts to modify it are undefined behaviour (see const member and assignment operator. How to avoid the undefined behavior?).

One way to do what you want is to write a nonmodifiable container that gives semantic const while leaving you as the programmer the possibility of modifying the contained value:

template<typename T> class nonmodifiable {
   T t;
public:
   nonmodifiable(T t): t{std::move(t)} {}
   operator const T &() const { return t; }
   nonmodifiable &operator=(const nonmodifiable &) = delete;
};

You can now write:

class Foo {
  nonmodifiable<int> _id;
  // etc.
};

and because neither _id nor its contained value are const, use the destruct-placement new dance to reassign its value:

Foo &operator=(const Foo &foo) {
   if (this != &foo) {
      _id.~nonmodifiable<int>();
      new (&_id) nonmodifiable<int>(foo._id);
   }
   return this;
}