C++ templates and pre-process macro - c++

Question

Consider following code
#include <iostream>
using namespace std;
template<int I>
int myfunc()
{
#if I
return 1;
#else
return 2;
#endif
};
int main()
{
cout<<myfunc<0>()<<endl;
cout<<myfunc<1>()<<endl;
}
But the output is
2
2
The motivation to do this is following:
I have an algorithm, which needs to be implemented in both double and fixed point. One solution is to use a head file to define data type based on macro flag, for example,
#ifdef __DOUBLE__
typedef double InputType;
.... // a lot of other types
typedef double OutputType;
#else //Fixed Point
typedef int InputType;
... // a lot of other types, which are matching with "__DOUBLE__" section
typedef int OutputType;
The drawback of this type of solution is that you can't compare the two implementations at the runtime. You have to set the macro accordingly twice, compile twice, and run twice, and then compare the collected data. Ideally, I would like to have a template function or template class with a nontype parameter, which allows me to switch between implementations
Any other methodology can achieve the similar goal (comparing two implementation at run-time) is also welcome!
Thanks

Answer 1

Option: Template Specialization
You can specialize templates to allow for separate implementations. Template specializations can de done for classes as well. Consider:
template<typename T>
void foo(T) {
//general implementation
}
template<>
void foo(double d) {
//do something special for doubles
}
template<>
void foo(float f) {
//do something else for floats
}
Option: Enum of types
This is similar to OpenGL. Something like this:
enum MyTypes {FLOAT, DOUBLE};
void foo(MyType _m) {
//do some generic stuff
switch(_m) {
case FLOAT:
//do something for float
break;
case DOUBLE:
//do something else for float
break;
default:
//runtime error
}
//do some other stuff
}
But it takes a parameter into the function instead of a template argument.