Overload function for arguments (not) deducable at compile time

Question

Is there a way to overload a function in a way to distinguish between the argument being evaluable at compile time or at runtime only?

Suppose I have the following function:

 std::string lookup(int x) {
     return table<x>::value;
 }

which allows me to select a string value based on the parameter x in constant time (with space overhead). However, in some cases x cannot be provided at compile time, and I need to run a version of foo which does the lookup with a higher time complexity.

I could use functions with a different name of course, but I would like to have an unified interface.

I accepted an answer, but I'm still interested if this distinction is possible with exactly the same function call.

Per your edit, the answers to [this question](http://stackoverflow.com/q/8936549/636019) would indicate 'no', unfortunately. If there _is_ a way, I'd certainly be fascinated to know! — ildjarn, Jan 14 '16 at 18:38

score 2 · Answer 1 · answered Jan 14 '16 at 15:25

2

One option would be to use overloading in a similar manner:

template <int x> std::string find() {
   return table<x>::value;
}

std::string find(int x) {
    return ...
}

answered Jan 14 '16 at 15:25

SergeyA

61,605
5
78
137

ildjarn · Accepted Answer · 2016-01-14T16:15:56.897

I believe the closest you can get is to overload lookup on int and std::integral_constant<int>; then, if the caller knows the value at compile-type, they can call the latter overload:

#include <type_traits>
#include <string>

std::string lookup(int const& x)                   // a
{
    return "a"; // high-complexity lookup using x
}

template<int x>
std::string lookup(std::integral_constant<int, x>) // b
{
    return "b"; // return table<x>::value;
}

template<typename T = void>
void lookup(int const&&)                           // c
{
    static_assert(
        !std::is_same<T, T>{},
        "to pass a compile-time constant to lookup, pass"
         " an instance of std::integral_constant<int>"
    );
}

template<int N>
using int_ = std::integral_constant<int, N>;

int main()
{
    int x = 3;
    int const y = 3;
    constexpr int z = 3;
    lookup(x);         // calls a
    lookup(y);         // calls a
    lookup(z);         // calls a
    lookup(int_<3>{}); // calls b
    lookup(3);         // calls c, compile-time error
}

Online Demo

Notes:

I've provided an int_ helper here so construction of std::integral_constant<int> is less verbose for the caller; this is optional.
Overload c will have false negatives (e.g. constexpr int variables are passed to overload a, not overload c), but this will weed out any actual int literals.

score 0 · Answer 3 · answered Jun 10 '20 at 17:20

There is also this trick:

std::string lookup(int x) {
    switch(x) {
    case 0: return table<0>::value;
    case 1: return table<1>::value;
    case 2: return table<2>::value;
    case 3: return table<3>::value;
    default: return generic_lookup(x);
}

This sort of thing works well when it's advantageous, but not required, for the integer to be known at compile time. For example, if it helps the optimizer. It can be hell on compile times though, if you're calling many instances of some complicated function in this way.

Overload function for arguments (not) deducable at compile time

3 Answers3