c++ pointer casting help, void* to boolean - c++

Question

Im learning C++ at the moment, and am having some issues with casting pointers. In the first place I am not sure that what I am trying to do is what I want to do..
I am trying to take a function that can return the appropriate pointer to various method pointers based on string parameters, and to then use the method pointer.
#include "stdafx.h"
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef void* (*plugin_function)(void*);
static class Plugin
{
public:
static bool doBoolStuff(){
return true;// A Simple function that returns true
}
};
void* getFunction(string pluginName, string functionName)
{
if(pluginName =="Bool"){
return &Plugin::doBoolStuff;
//If the string is right it should return a method pointer.
//I think that void* has the ability to point to anything, I am trying
//to use that functionality to create a system where I am able to set
//some parameters and get the appropriate method pointer.
}else{
return NULL;
}
}
int main(int argc, _TCHAR* argv[])
{
void* pluginFunction;
pluginFunction = getFunction("Bool","");
if(pluginFunction == &Plugin::doBoolStuff)cout<<"CastSuccesful!"<<endl;
//This section right here is where my code is breaking.
//
// IntelliSense: expression preceding parentheses of apparent call must have
//(pointer-to-) function type
//c:\Users\Walter\Dropbox\Inscription\MethodCasting\MethodCasting\MethodCasting.cpp
//MethodCasting
cout << "Bool function ->"<< pluginFunction()<<endl;
cout << "--------------------------------"<<endl;
system("pause");
}
Any feedback would be helpful.

Answer 1

Edit: Not true, sorry. As #Stephen Lin pointed out, I failed to read the static modifier... So while what you want doesn't work for non-static member functions, it usually does work for static members using reinterpret_cast (this behavior is implementation-defined):
class Plugin {
public:
static bool foo()
{
std::cout << "Foo called!" << std::endl;
return true;
}
};
void *get_func()
{
return reinterpret_cast<void *>(&Plugin::foo);
}
int main()
{
void *pluginFunction = get_func();
(reinterpret_cast<bool (*)()>(pluginFunction))();
return 0;
}
Original post:
You can't. According to this article:
However, there is no way to cast the void * back to a member function pointer that you could actually use.
I've tried it myself. Actually, all of static_cast, reinterpret_cast and even old C-style casts refused to work - neither with void *, nor with bool (*)() (yes, I've even tried to cast from a non-member function pointer type to a member function type)...
Sorry, C++ doesn't seem to allow us to do this.

Answer 2

It depends on your implementation, if you can do this. In portable C++ you can't. And even if you can, you need explicit casts (in this case reinterpret_cast<>) to convert between different pointer types.
Note that this does not extend to real "method" pointers, that is to non-static member function pointers. You cannot convert between member function pointers and either object pointers or ordinary function pointers. The approach I present at the end can be used, if you only have non-static member function pointers.
Portably reinterpret_cast<> can freely convert between function pointer types and object pointer types - although any use of the result except conversion back to the original type is undefined in almost all cases.
For conversions between object pointer types and function pointer types, the C++11 standard says (§5.2.10 [expr.reinterpret.cast]/8):
Converting a function pointer to an object pointer type or vice versa
is conditionally-supported. The meaning of such a conversion is
implementation-defined, except that if an implementation supports
conversions in both directions, converting a prvalue of one type to
the other type and back, possibly with different cv- qualification,
shall yield the original pointer value.
So, it depends on your implementation (and should be documented in its documentation), if casting a function pointer to a void * compiles and back compiles at all. Alas, if it does, you should get the expected behavior.
In your code the casts are missing. You need a cast to the generic type (in your case void*) in getFunction and you need to cast back to the original type in order to call the function. So you will need to know the original type in main():
void* pluginFunction = getFunction("Bool","");
// ....
cout << "Bool function ->"<< (reinterpret_cast<bool (*)()>(pluginFunction))()<<endl;
A more portable solution would be to use an arbitrary function pointer type, for example void (*)() to pass plugin function pointers around, so that you have:
typedef void (*any_func_ptr)();
// If you wanted to use this for non-static member functions, you could do
// struct AnyClass;
// typedef void (AnyClass::*any_memfun_ptr)();
any_func_ptr getFunction(string pluginName, string functionName)
{
if(pluginName =="Bool"){
return reinterpret_cast<any_func_ptr>(&Plugin::doBoolStuff);
}else{
return NULL;
}
}
int main(int argc, char* argv[])
{
any_func_ptr pluginFunction = getFunction("Bool","");
if(reinterpret_cast<bool (*)()>(pluginFunction) ==
&Plugin::doBoolStuff)
cout<<"CastSuccesful!"<<endl;
cout << "Bool function ->"<< (reinterpret_cast<bool (*)()>(pluginFunction))()<<endl;
}