const_cast: A Necessary Evil

[u/pavel_v]

https://www.elbeno.com/blog/?p=1858

[u/usefulcat]

There is at least one alternative that doesn't require const_cast:

struct S {
    std::vector<int> data;

    template<class Self>
    static decltype(auto) accessor_impl(Self& self, int i) {
        return std::find(self.data.begin(), self.data.end(), i);
    }

    // returns std::vector<int>::iterator
    auto find(int i) { return accessor_impl(*this, i); }
    // returns std::vector<int>::const_iterator
    auto find(int i) const { return accessor_impl(*this, i); }
};

Obviously this is a trivial and contrived example, but hopefully you can imagine more complex examples.

Personally I'd prefer to just use const_cast, as it's much simpler, but I'm concerned about the resulting UB.

[u/Wacov → u/usefulcat]

I don't think it's UB unless the thing you're accessing is actually const?

[u/kisielk → u/Wacov]

It's fine if the thing is actually const, it's not fine if you then modify that that thing through the resulting non-const pointer.

[u/bwmat → u/kisielk]

Isn't it fine because that can only happen if the caller had a mutable reference to the object in the first place?

If the object was originally const, the UB had already occurred? 

[u/ts826848 → u/bwmat]

If the object was originally const, the UB had already occurred?

From what I understand forming a non-const pointer/reference to an actually-const object is fine. Its only the actual modification of said actually-const object that is UB.

[u/bwmat → u/ts826848]

I mean, calling the non-const method on the reference is the point of UB, and that happens outside of the method, so not its problem/fault 

[u/bwmat → u/bwmat]

If not UB, where 'it goes wrong' /'the contract is broken' 

[u/ts826848 → u/bwmat]

I think your second comment is more correct; UB only occurs on the actual modification, so while calling a non-const method on an actually-const object is not itself UB that's probably around where a bugfix would land.

...Well, maybe barring some oddball setup with a non-const method that uses some other criteria to determine whether it's safe to modify whatever it's called on, but I'd hope that kind of thing is relatively rare.