Avoid if-else statement with template function

Question

If I have some code like this:

void function_1(...)
{
    //do something
}


void function_2(...)
{
    //do something
}


int function_3(...)
{
    //do something
}

int main()
{
    ....
    if (CONSTANT_1) function_1()
    else if (CONSTANT_2) function_2()
    else if (CONSTANT_3) function_3()
    ....    
}

I would like avoid the if-else statement and do something like this in main function:

int main()
{
    function<CONSTANT>();
}

How can I avoid the use of if-else statement and simulate this behavior?

Answer 1

Overload and tag dispatch. The Base template will convert the constant into a unique type. Then simple overload resolution will choose the proper overload. This is all assuming the constant are constexpr, and not something known only at run-time.

void function(std::integral_constant<int, CONSTANT_1>)
{
    //do something
}


void function(std::integral_constant<int, CONSTANT_2>)
{
    //do something
}


int function(std::integral_constant<int, CONSTANT_3>)
{
    //do something
}

template<int constant>
auto function()
{
  return function(std::integral_constant<int, constant>{});
}

int main()
{
  function<CONSTANT_2>(); // calls the second overload
}

The above has the benefit of issuing a compile time error when an overload isn't found, as opposed to a linkage error if you specialize template functions instead.

Answer 2

In general you can specialize the function template:

template<int N>
void function();

template<>
void function<1>()
{
    //do something
}

template<>
void function<2>()
{
    //do something
}

template<>
void function<3>()
{
    //do something
}

This works, but there might be better solutions as well.