Assign generic function to function pointer struct memeber - c++

Question

I have to assign the following member of a struct:
esp_err_t (*handler)(httpd_req_t *r);
As you can see, it is a function pointer. I have a generic template function that I would like to assign as handler:
template <class Tmsg>
esp_err_t HandleRpc(httpd_req_t *req){...}
I am assigning the handler member inside a generic template class, so I have a generic type argument Tpayload:
httpd_uri_t cfg = {
...
.handler = HandleRpc<Tpayload>,
...
};
I get:
expected primary-expression before '>' token
The issue lies in the fact that I can't pass a member method pointer (I.E. esp_err_t (RpcServer::*)(...)), but RpcServer is a generic template class (I.E. has a template with one generic parameter). So I thought that by creating a generic template function outisde the class (global scope?), and passing the RpcServer instance into that function, I would be able to retrieve my instance of RpcServer<T> and all would be well.
Here is the smallest amount of code I could come up with to reproduce the issue:
int main()
{
}
template <class T>
class RpcServer{
public:
void RegisterHandler();
};
struct HandlerInfo{
void (*handler)();
};
template <class T>
void Handle(RpcServer<T> test)
{
}
template <class T>
void RpcServer<T>::RegisterHandler(){
HandlerInfo info = {
.handler = Handle<T>;
};
}
Am I missing the obvious, or is what I am trying to do going to require some uglier trickery?

Answer 1

struct HandlerInfo{
void (*handler)();
};
handler is a pointer to a function that takes no parameters, and doesn't return anything. You can set this pointer to point to any function. As long as it takes no parameters, and doesn't return anything (its return type is void). There are no exceptions to this, this is how C++ works, it is a strongly-typed language.
template <class T>
void Handle(RpcServer<T> test)
{
This is a template for a function that takes one parameter. The type of the parameter is not material. The point is that every instance of this template will be a function that takes exactly one parameter, always.
In C++, a pointer to a function that has no parameters can only be set to point to such a function. You cannot set this function pointer to point to a function that takes one parameter, or two parameters, or ten parameters. It can only be set to a function that takes exactly zero parameters. That's because that's what the pointer points to.
If you were to change the template function so that it takes no parameters, then this would work, of course:
int main()
{
}
template <class T>
class RpcServer{
public:
void RegisterHandler();
};
struct HandlerInfo{
void (*handler)();
};
template <class T>
void Handle()
{
}
template <class T>
void RpcServer<T>::RegisterHandler(){
HandlerInfo info = {
.handler = Handle<T>
};
}
This compiles on gcc 10. ".member" initialization syntax has been supported by gcc for a long time, but it's only been standardized as of C++20, so other compilers may not support this syntax.
You could, if you wish, declare this to be a pointer to a function that takes an RpcServer<int> as its parameter:
struct HandlerInfo{
void (*handler)(RpcServer<int>);
};
Now, you will be able to initialize it to point to such a function:
HandlerInfo info = {
.handler = Handle<int>
};
HandleInt instantiates a function that takes such a parameter, so the types match exactly.
Or, alternatively, make HandlerInfo itself a matching template:
template <class T>
class RpcServer{
public:
void RegisterHandler();
};
template<class T>
struct HandlerInfo{
void (*handler)(RpcServer<T>);
};
template <class T>
void Handle(RpcServer<T> )
{
}
template <class T>
void RpcServer<T>::RegisterHandler(){
HandlerInfo<T> info = {
.handler = Handle<T>
};
}
int main()
{
RpcServer<int> server;
server.RegisterHandler();
}
(Note -- your code has other syntax errors; if they were fixed it would seem that, at first, the code would compie; but if an attempt was made to instantiate the templates, it would fail due to the type mismatch)