Question

If I try to define a pointer to an overloaded function

void myprint(int );
void myprint(const char* );
void (*funpointer)(int) = myprint;

the compiler understands that funpointer should point to the version of myprint that matches its arguments. Instead, I want funpointer to be overloaded as well.
I tried simply adding a couple lines like

void myprint(int );
void myprint(const char* );
void (*funpointer)(int);
void (*funpointer)(const char *);
void funpointer = myprint;

but then the compiler complains of conflicting declarations for funpointer (obviously).

Is there a way to achieve what I’m looking for? I would like the pointer to behave as an overloaded function. So I could call it as either funpointer(1) or funpointer("Hey.") and it would work as the respective version of myprint.

Answer 1

Why are you doing this? Function pointers are for runtime polymorphism based on application state. Plain old overloads work fine if, the only variance is the argument type.

If you want to be able to, say write a library that will call overloads defined later, in client code, do something like the following:

void foo(int x) { printf("int\n");}
void foo(const char* c){ printf("char*\n"); }

template <class T> void callfoo(T t) { foo(t); }

int main(int argc, char* argv[])
{
    int x = 3;
    callfoo(x);

    const char* p = "Hello world";
    callfoo(p); 

    return 0;
}

This allows the lib to call overloads for types it is not actually aware of until link time.