Trying to call a function pointer causes a compile error with GNU G++

Hi,

I've got this class that parses command line input, which won't
compile, the error message is:

% g++ buggy.cpp -o buggy
buggy.cpp: In member function =E2=80=98int Command::execute()=E2=80=99:
buggy.cpp:110: error: must use =E2=80=98.*=E2=80=99 or =E2=80=98->*=E2=80=
=99 to call pointer-to-member
 function in =E2=80=98((Command*)this)->Command::cmd.
 std::_Rb_tree_iterator<_Tp>::operator-> [with _Tp = std::pair<const
 Command::ELEMENT, int>]()->std::pair<const Command::ELEMENT,
 int>::first.Command::ELEMENT::function (...)=E2=80=99

And the code itself is as follows (I've simply boiled it down to a
short 124 line program) I'd be grateful if you can point out what I'm
doing wrong when calling via Command::execute(), many thanks!

#include <iostream>
#include <map>
#include <vector>
#include <string>
#include <cassert>

class Command
{
public:
    Command(std::vector<std::string>& arguments);
    ~Command();

    int execute();

    struct ELEMENT
    {
    public:
        bool operator==(const ELEMENT& rhs) const
        {
            return (strcasecmp(command.c_str(), rhs.command.c_str()) == 0);
        }

        bool operator<(const ELEMENT& rhs) const
        {
            return (strcasecmp(command.c_str(), rhs.command.c_str()) != 0);
        }

        friend std::ostream& operator<<(std::ostream& os, const ELEMENT& rhs);

        std::string command;
        int (Command::*function)();
    };

private:
    int a(void);
    int b(void);
    int c(void);

    static const int COMMANDS;
    static const ELEMENT command_table[];

    std::map<ELEMENT, int>* commands;
    std::map<ELEMENT, int>::iterator cmd;
};

const int Command::COMMANDS = 3;
const Command::ELEMENT Command::command_table[Command::COMMANDS] =
{
    { "a", &Command::a },
    { "b", &Command::b },
    { "c", &Command::c }
};

std::ostream& operator<<(std::ostream& os, const Command::ELEMENT& rhs)
{
    os << rhs.command;
    return os;
}

Command::Command(std::vector<std::string>& arguments)
{
    typedef std::pair<ELEMENT, int> command;
    commands = new std::map<ELEMENT, int>;
    cmd = commands->end(); // make sure it's set to the end

    for (int i = 0; i < COMMANDS; i++)
        commands->insert(command(command_table[i], i));

    assert((int)commands->size() == COMMANDS);

    if (arguments.size() > 0)
    {
        cmd = commands->begin();
        while (cmd != commands->end())
        {
            if (strcasecmp(cmd->first.command.c_str(), arguments[0].c_str()) == =
0)
            {
                arguments.erase(arguments.begin());
                break; // We've got the command
            }

            cmd++;
        }
    }
}

Command::~Command()
{
    delete commands;
}

int Command::a(void)
{
    std::cout << "a\n";
}

int Command::b(void)
{
    std::cout << "b\n";
}

int Command::c(void)
{
    std::cout << "c\n";
}

int Command::execute()
{
    if (cmd->first.function != NULL)
        return (cmd->first.function)();

    return -1;
}

int main(int argc, char* argv[])
{
    std::vector<std::string> arguments;
    for (int i = 1; i < argc; i++)
        arguments.push_back(argv[i]);

    Command command(arguments);
    command.execute();
}

--
http://www.munted.org.uk

Fearsome grindings.