C++ map<char, static method pointer>? [duplicate]

1: Remove static from your typedef, like:

typedef IValue * (*returnPtrIValue)();

Pointer to static member function can be then assigned to the variable (or be put into map) of that type , like:

returnPtrIValue fun = &SomeClass::somestaticfun;

Is this what you are asking for?

2: Generally speaking - no. Not in typesafe way, at least. Covariance does not work in C++ that way.

If you really want to do this you can do this is with either reinterpret_cast or doing some hackery with unions, but this may be compiler-dependant and I wouldn't recommend that (I can give you some hints if you do want this anyway).

UPDATE: Here is the really good article, that explains how to implement delegates in C++ with help of (member) function pointers in C++. It delves pretty deeply into the question and I've found that the first half of it is pretty good reference/explanation of (member) function pointers in C++ and how to work with them. I suggest to check it out if you're interested in understanding how they work in C++.

1) Just remove static from your typedef, a "static method" is like a simple function (only declared inside the scope of a class).

2) That seemed legit but unfortunately I get a compiler error:

error: invalid conversion from 'B* (*)()' to 'A* (*)()'

It seems that function pointers don't support covariant return types...

If you're using C++11, you can try something like this:

#include <map>
#include <functional>
...
std::map<char, std::function<parser*()>> m;
m['a'] = []{return new parser_for_a;};

This way you don't need to have any static methods.

This code should answer your questions, even if not exactly. In fact, I solved some of your issues by using virtual calls (beware: performance issues).

#include <iostream>
#include <map>


struct parse_result {
    // something here
};

class parser {
public:
    virtual parse_result parse() = 0;
};

class parser1 : public parser {
public:
    parse_result parse() {
        // something here
        std::cout << "Called parser1::parse()" << std::endl;
        return parse_result();
    }
};

class parser2 : public parser {
public:
    parse_result parse() {
        // something here
        std::cout << "Called parser2::parse()" << std::endl;
        return parse_result();
    }
};

static parser1* make_parser1() {
    return new parser1();
}

static parser2* make_parser2() {
    return new parser2();
}

typedef parser* (*parser_factory_method)();


int main() {

    std::map<char, parser_factory_method> parsers;
    parsers.insert(std::make_pair('1', (parser_factory_method) make_parser1));
    parsers.insert(std::make_pair('2', (parser_factory_method) make_parser2));

    for (auto entry : parsers) {
        std::cout << "Calling parser for " << entry.first << std::endl;
        parser_factory_method pfm = entry.second;
        parser* p = pfm();
        p->parse(); // parse_result is ignored here, but can be used as needed
        delete p;
    }

    return 0;

}

Please note that I don't like this design for a parser. It mimics Java reflection somehow and it is doomed to have performance issues. See if you can refine it.