What's wrong with the initializer?

[xuinkrbin]

I am trying to create a `std::map` from `std:: string` to a pointer to member function type. I'm initializing the `map` with an initializer list (braced). When I compile, I get a message from the compiler: No matching constructor for initialization. Example: http://pastebin.com/y3ZvHCZ8 Any thoughts as to what I am doing wrong?

[Peter87]

Use curly brackets.

void f() {
    static std::map<std::string, A::B> strToFunction {
        { "string1",       &A::B1 },
        { "string2",       &A::B2 }
    };
}

[JLBorges]

#include <string>
#include <map>

struct A
{
    using mem_fun_ptr_type = int (A::*)(int,double) ;

    int foo( int a, double b ) { return a+b ; }
    int bar( int a, double b ) { return a*b ; }
};

int main()
{
    std::map< std::string, A::mem_fun_ptr_type > map { { "foo", &A::foo }, { "bar", &A::bar } } ;
}

Consider exploiting the flexibility provided by the polymorphic call wrapper: http://en.cppreference.com/w/cpp/utility/functional/function

[xuinkrbin]

Thanks to Both.

When I make the recommended adjustments, the compiler still rejects attempts to actually use the resultant pointer:

...
auto c = mapFromJLBorges["foo"];
someAObject.*c(1, 2.0);
...

I'm thinking pointer to member just are not for Me.

[JLBorges]

#include <string>
#include <map>
#include <functional>

struct A
{
    using mem_fun_ptr_type = int (A::*)(int,double) ;

    int foo( int a, double b ) { return a+b ; }
    int bar( int a, double b ) { return a*b ; }
};

int main()
{
    A a ;
    A* pa = std::addressof(a) ;

    {
        std::map< std::string, A::mem_fun_ptr_type > map { { "foo", &A::foo }, { "bar", &A::bar } } ;
        auto pmfn = map["foo"] ;
        (a.*pmfn)( 1, 2.3 ) ;
        (pa->*pmfn)( 1, 2.3 ) ;
    }

    {
        std::map< std::string, std::function< int( A&, int, double ) > > map { { "foo", &A::foo }, { "bar", &A::bar } } ;
        auto fn = map["foo"] ;
        fn( a, 1, 2.3 ) ;
    }

    {
        std::map< std::string, std::function< long( A*, int, int ) > > map { { "foo", &A::foo }, { "bar", &A::bar } } ;
        auto fn = map["bar"] ;
        fn( pa, 1, 2.3 ) ;
    }
}