Arrays of Templated Function Pointers

This class was a random challenge that a student game me. he was looking for a way to pass an array of function pointers to functions that take templated parameters. This was an interesting idea so I worked though it with him and here it is for anyone else to view if they would like to

There are problems with doing something this obstufocated. First it is going to be hard for many programmers to really understand what you are doing and why. And second this is a very specific implementation and generally when you could use this, you could use something else to do it in an easier to understand method. With that said I still think it is an interesting challenge and can be useful in rare situations.

Let’s start by making some easy templated functions

/////////////////////////////////////////////////// // The templated functions we will use // to test the Array of function pointers to templated functions /////////////////////////////////////////////////// template <typename Type> void Print(Type v) { cout << v; } template <typename Type> void PrintWithTrailingSpace(Type v) { cout << v << ' '; } template <typename Type> void PrintWithLeadingSpace(Type v) { cout << ' ' << v; } template <typename Type> void PrintWithTrailingNewline(Type v) { cout << v << '\n'; }

So this challenge brings up one major flaw. You can have a templated function just fine but you can't have a templated array without it being inside of something else that is templated like a struct or class. So to get this implementation to work we must make a struct to handle the templating for us.

Here was my first thought on this.

///////////////////////////////////////////////////////////// // Array of function pointers to templated functions // You need to create an instance of this structure to use it // (outdated use the one below) ///////////////////////////////////////////////////////////// template <typename Type> struct funcpoint { void (*func[4])(Type v); funcpoint() { func[0]=Print; func[1]=PrintWithTrailingSpace; func[2]=PrintWithLeadingSpace; func[3]=PrintWithTrailingNewline; } };

Though that works, it requires you to make an instance of the structure to use it. Not the most elegant solution that is for sure. So let’s fix that problem.

//////////////////////////////////////////////////////////////////// // Array of function pointers to templated functions // Using static to avoid having to make a instance of the structure //////////////////////////////////////////////////////////////////// template <typename Type> struct funcpoint2 { void static(*func[4])(Type v); }; //Initialization of the static member template <typename Type> void (*funcpoint2<Type>::func[4])(Type v) = { Print, PrintWithTrailingSpace, PrintWithLeadingSpace, PrintWithTrailingNewline };

Now with this implementation we can call the functions whenever we would like. Let's take a look at how we can use this implementation.

///////////////////////////////////////////////////////////////// //main() // Our primary routine. This is called when the program starts. // // Return: We always return 0. ///////////////////////////////////////////////////////////////// int main(void) { funcpoint2<const char*>::func[1]("The answer to life the universes and everything is"); funcpoint2<int>::func[3](42); funcpoint2<const char*>::func[0]("\n\n\n"); funcpoint2<const char*>::func[0]("It's not my fault."); funcpoint2<const char*>::func[2]("I told you you wouldn't like it."); funcpoint2<const char*>::func[0]("\n\n\n"); return 0; // No problemos! }

This is still not a perfect implementation though. The function pointers can only be set one time, during initialization and the array is always going to be of 4 function pointers. Not any other number. So far it has not been necessary for me to fix that flaw. In the future if I ever do, or if people would like to expand on this more and email me asking me to do so, I will fix these problems.