Call function pointer using map - c++

Question

I am begginer in C++ and
I have the following template class:
template<typename... extensions>
class SomeServiceProxy
{
public:
void DoSomething() {std::cout<<"\ndoing sth\n";};
};
With the following pointer to function using "using" keyword
template<typename... extensions>
using DoSomethingFnPtr = void (SomeServiceProxy<extensions...>::*)();
And I am trying to put the method in a map and call it:
std::map<int, void*> myMap;
int main()
{
SomeServiceProxy<int> proxy;
DoSomethingFnPtr<int> memfnptr = &SomeServiceProxy<int>::DoSomething;
proxy.DoSomething();
(proxy.*memfnptr)(); //works
myMap[0]= &memfnptr;
auto it=myMap.find(0);
if(it != myMap.end() ){
SomeServiceProxy<int> proxy2;
(proxy2.&(it->second))(); //error
}
std::cout<<endl;
return 0;
}
What I get is : error: expected unqualified-id before ‘&’ token
Q: Is there any way to call the method using the map?

Answer 1

A void* is not a member function pointer. And memfnptr is a member function pointer, you should store it in the map rather than a pointer to it.
This is your code made to compile with the most obvious fixes:
#include <map>
#include <iostream>
template<typename... extensions>
class SomeServiceProxy
{
public:
void DoSomething() {std::cout<<"\ndoing sth\n";};
};
template<typename... extensions>
using DoSomethingFnPtr = void (SomeServiceProxy<extensions...>::*)();
std::map<int, DoSomethingFnPtr<int>> myMap;
int main()
{
SomeServiceProxy<int> proxy;
DoSomethingFnPtr<int> memfnptr = &SomeServiceProxy<int>::DoSomething;
proxy.DoSomething();
(proxy.*memfnptr)(); //works
myMap[0]= memfnptr;
auto it=myMap.find(0);
if(it != myMap.end() ){
SomeServiceProxy<int> proxy2;
(proxy2.*(it->second))(); //error
}
std::cout<<std::endl;
return 0;
}
I suppose you want to store member function pointers for different instantiations of SomeServiceProxy in the same map and thats why you used void*. There are much better ways to do type erasure than using void*, though what is more or less universal with type erasure is: Erasing the type is the easy part. The difficult part is to restore the type when you need it. When you store member function pointers for different instantiations of SomeServiceProxy in the same map then you can only call them when you know what instantiation of the template it is.
The simple solution is to use a std::map<int, std::function<void()>> then store lambdas (or some other functor) that encapsulates the instance and the member function to be called. For example:
std::map< int , std::function<void()>> mymap;
mymap[0] = []() {
SomeServiceProxy<int> proxy;
proxy.DoSomething();
};
mymap[0]();