Is it possible to return a non-const iterator from an unordered_set with a custom_key?

[hinchcmark]

From the answer here: https://stackoverflow.com/questions/18704129/unordered-set-non-const-iterator
"Both set and unordered_set have read-only keys." If this is the case should the non-const iterator be publically accessible for these types?

I'm using the Microsoft compiler (VS2019 v142 :::: /std:c++17).

I create a custom key type for an unordered_set and a hasher for it.

std::unordered_set<custom_key, custom_hasher> ids;

I then call:

 std::generate(ids.begin(), ids.end(), [](){return custom_key();});

This fails to compile with the following message:

1>... error C2678: binary '=': no operator found which takes a left-hand operand of type 'const custom_key' (or there is no acceptable conversion)

double clicking this takes me into the std::generate function specifically *_UFirst = _Func();:

    // FUNCTION TEMPLATE generate
    template <class _FwdIt, class _Fn>
    _CONSTEXPR20 void generate(_FwdIt _First, _FwdIt _Last, _Fn _Func) { // replace [_First, _Last) with _Func()
        _Adl_verify_range(_First, _Last);
        auto _UFirst      = _Get_unwrapped(_First);
        const auto _ULast = _Get_unwrapped(_Last);
        for (; _UFirst != _ULast; ++_UFirst) {
            *_UFirst = _Func(); // <---- THIS LINE
        }
    }

So it's erroring out as *_UFirst is evaluating to be const custom_key and we can't assign to const.

I double checked everything my end and I had no const's in my code so something must be turning it const.

Commenting out the std::generate I did a localized test and sure enough I get the same issue:

    std::unordered_set<VMSID, VMSID_Hash>::iterator a = ids.begin();
    *a = custom_key(); // <---- THIS LINE

It seems as though unordered_set::iterator uses it's base iterator from std::_Hash which uses:

conditional_t<is_same_v<key_type, value_type>, typename _Mylist::const_iterator, typename _Mylist::iterator>;

is_same_v<key_type, value_type> always comes out true, so it only ever returns the const_iterator!

[cpplearner]

As mentioned in the Q&A, non-const element access is intentionally disabled, because modification of elements in a std::unordered_set will change the elements' hash value and thus disrupt the internal organization of std::unordered_set.

In C++17, it is possible to extract nodes from a std::unordered_set, modify their value()s while they are not stored in a container, and then insert them back to the container.

[hinchcmark]

Thanks for the reply. I understand this, my question is regarding why expose the non-const iterator functions publicly? Considering its not what you actually get given. If your API is providing begin and end that say they return non-const iterators, that's what I'm expecting to get back. Now there may be a really good reason they are exposed publicly, hence the question.

[miscco]

The answer here is generics

You would not want to have to special case associative and sequence containers all the time in generic code