Question

Consider that in some library somewhere (which we have no access to change), we have a Counter class:

class Counter {
    int count;
  public:
    Counter() : count(0) { }
    void bump() { ++count; }
    int getCount() const { return count; }
};

which, by its very nature, is mutable. If it’s const, it’s pretty worthless.

And in our code, we “use” that Counter. Badly.

#include <string>
#include <iostream>
#include <Counter.hpp>

using std::cout;
using std::endl;

void breakTheHellOutOfCounter(Counter &c) {
    // This is OK
    c.bump();

    // Oh noes!
    c = Counter();
}

int main() {
    Counter c;
    c.bump(); c.bump(); c.bump();
    std::cout << "Count was " << c.getCount() << std::endl;
    breakTheHellOutOfCounter(c);
    std::cout << "Count is now " << c.getCount() << std::endl;
}

Note that breakTheHellOutOfCounter overwrites main‘s counter with a shiny new one, resetting the count. That’s going to cause the caller some grief. (Imagine something a lot more harmful happening, and you’ll see where I’m going here.)

I need to be able to bump c (and thus, I need it mutable), but I want breakTheHellOutOfCounter() to fail miserably due to trying to replace c. Is there a way I can change things (other than the Counter class) to make that happen?

(I’m aware that at the lowest levels, this is all but impossible to enforce. What I want is a way to make it hard to do accidentally.)

Answer 1

The simplest way to do this is to remove the assignment operator from the Counter class. However, since you don’t have the ability to change the Counter class, your only real option is to wrap the Counter class in a class with no assignment operator and use that instead.