2

I am trying to use the following struct as a custom key for std::map:

struct ActionId {
        // ENCAPSULATED MEMBERS
    private:
        size_t _id;
        static size_t _root;
        static size_t incrementedRoot() {
            return (_root += 1);
        }

        // INTERFACE
    public:
        ActionId() :
            _id(incrementedRoot()) { }
        ActionId(const ActionId& that) :
            _id(that._id) { }
        ActionId& operator=(const ActionId& that) {
            this->_id = that._id;
            return *this;
        }
        bool operator==(const ActionId& that) const {
            return this->_id == that._id;
        }
        bool operator!=(const ActionId& that) const {
            return this->_id != that._id;
        }
        bool operator<(const ActionId& that) const {
            return this->_id < that._id;
        } 
};

The following dictionary is a member of a separate InputManager class:

std::map<ActionId, std::set<sf::Keyboard::Key>> _keyBindings;

which is accessed in this member function:

std::set<sf::Keyboard::Key> InputManager::keysBoundTo(ActionId action) const {
    return _keyBindings[action];
}

Unfortunately, the function is throwing this compiler error:

error C2678: binary '[' : no operator found which takes a left-hand operand of type 'const std::map<Game2D::ActionId,std::set<sf::Keyboard::Key,std::less<_Kty>,std::allocator<_Kty>>,std::less<Game2D::ActionId>,std::allocator<std::pair<const Game2D::ActionId,_Ty>>>' (or there is no acceptable conversion)

According to this article, the operator<() member of ActionId with const qualification should be sufficient to make it a custom map key, while this article says that all I need is to make ActionId copiable and assignable. Clearly, my struct meets both of these criteria, so why won't InputManager::keysBoundTo() compile?

Community
  • 1
  • 1
Rabadash8820
  • 2,328
  • 3
  • 27
  • 49

1 Answers1

1

The index operator (the "[]") is a non-const member function of std::map. Whereas, you have clearly indicated that keysBoundTo is a const member.

Rewrite keysBoundTo as

std::set<sf::Keyboard::Key> InputManager::keysBoundTo(ActionId action) const
{
    auto it = keyBindigs_.find(action);
    if ( it == keyBindings_.end() )
        return std::set<sf::Keyboard::Key>();
    else
        return it->second;
}

Notice that I renamed your member variable to have a trailing underscore. Do not use identifiers with leading underscores.

Happy Green Kid Naps
  • 1,611
  • 11
  • 18
  • Wow, never would've thought of that. So are you saying that, in this case, operator[] is returning a modifiable `std::set<>&` object, and there is no conversion from that to `const std::set<>&`? I find that rather surprising. Your code compiles just fine though, thanks :) Also, why don't you recommend leading underscores? – Rabadash8820 Aug 05 '15 at 18:28
  • No, it is not to do with the value (the set in this case) being modifiable or non-modifiable. As I said in my answer, std::map's operator[] is a *non-const* member. It _could_ modify the map (insert the key corresponding to the input if it is not found). – Happy Green Kid Naps Aug 05 '15 at 18:38
  • Identifiers with leading underscores are reserved by the implementation (i.e., the compiler writer). – Happy Green Kid Naps Aug 05 '15 at 18:38
  • @HappyGreenKidNaps That's a simplification. `_Ugly` and `__ugly` are reserved everywhere. `_ugly` is reserved only in the global namespace – T.C. Aug 08 '15 at 05:11