Conditional compilation of overloaded functions in template classes - c++

Question

Imagine a class (in VS2010, no variadic templates here sorry)
template <class Arg>
class FunctionWrapper
{
public:
void Invoke(Arg arg){_fn(arg)};
private:
std::function<void(Arg)> _fn;
}
I can then do e.g.
FunctionWrapper <int> foo; foo.Invoke(4);
And this compiles fine. But this does not:
FunctionWrapper <void> foo; foo.Invoke();
Now, I could get around this using template specialization. But I also wondered if there was a way I could get around this another way....
template <class Arg>
class FunctionWrapper
{
public:
void Invoke(void){_fn()}; // } overloaded
void Invoke(Arg arg){_fn(arg)}; // }
private:
std::function<void(Arg)> _fn;
}
i.e. Overload Invoke, and then reply on conditional compilation so that if I instantiate
FunctionWrapper<void>,
the version of Invoke with the argument never gets compiled. I'm sure I read how to do this in Modern C++ design, but I can't remember the details.....

Answer 1

If you were trying to implement a functor this way there would be a number of obvious flaws in the design; I assume, and you seem to make it clear on the comments, that the code is just, well, an example used to state your case.
Here are a couple of solutions to the problem:
template<class T>
struct Trait{
typedef T type;
typedef T mock_type;
};
template<>
struct Trait<void>{
typedef void type;
typedef int mock_type;
};
template <class Arg>
class FunctionWrapper
{
public:
void Invoke(void){_fn();}
void Invoke(typename Trait<Arg>::mock_type arg){_fn(arg);}
boost::function<void(typename Trait<Arg>::type)> _fn;
private:
};
template <class Arg>
class FunctionWrapper2
{
public:
FunctionWrapper2(const boost::function<void(Arg)> arg) : Invoke(arg){}
const boost::function<void(Arg)> Invoke;
};
int main(int argc, _TCHAR* argv[])
{
FunctionWrapper<int> cobi;
cobi._fn = &countOnBits<int>;
cobi.Invoke(5);
FunctionWrapper<void> cobv;
cobv._fn = &func;
cobv.Invoke();
FunctionWrapper2<int> cobi2(&countOnBits<int>);
cobi2.Invoke(5);
FunctionWrapper2<void> cobv2(&func);
cobv2.Invoke();
//[...]
}
Of course I'm not saying that what I wrote is good code, as for the question it is only intended to provide examples of working constructs.
The problem with your attempt is that while the function void Invoke(Arg arg){_fn(arg)}; is actually not being compiled when you instanciate FunctionWrapper (and don't make any attempt at invoking the Invoke function with a parameter), it gets syntactically checked; and of course Invoke(void arg) is not something your compiler is going to accept!
This is my first answer on stackoverflow, I hope I had everything right; if not, please give me some feedback and don't get too upset at me :)