Well, here's an example. Suppose I have some class `foo` that manages a bunch of strings (for whatever reason, you could think things like string pools, tokenizers, parsers, ...) You might have a method that returns a string but it does it with `const std::string& get_string(...);` because of course you don't want the user messing with the string But the strings aren't really const under the hood and your container allows you to do some controlled modifying operations, e.g. `foo.update_string(str);` but it has to be implemented as `void update_string(const std::string&)` for the earlier API. The const_cast it will then do is completely correct. Now you can argue that really this should be done with wrapper objects, but that's a massive pain both for the implementer and the user. So I'd argue this is reasonable.
i would love to see the data, not gonna happen, of how much work this is along wtih all the crap that follows vs refactoring in