How to prevent a function from accidentally becoming recursive?

Consider the following C++ code:

#include <iostream>

void get_val_from_db(const char* key, signed char& value)
{
    std::cout << "Getting value from db with signed char!\n";
}

void get_val_from_db(const char* key, unsigned char& value)
{
    std::cout << "Getting value from db with unsigned char!\n";
}

// overload to convert first argument from std::string to const char*
template <typename T>
void get_val_from_db(const std::string& key, T& value)
{
    get_val_from_db(key.c_str(), value);
}


int main()
{
    unsigned char my_value_unsigned = 0; // OK!
    get_val_from_db("my key", my_value_unsigned);

    signed char my_value_signed = 0; // OK!
    get_val_from_db("my key", my_value_signed);
    
    char my_value_char = 0; // NOK! Can't convert! Becomes recursive!
    get_val_from_db("my key", my_value_char);

    // Can't remove the std::string conversion altogether because these needs to keep working
    std::string key = "my key";
    get_val_from_db(key, my_value_signed);
    get_val_from_db(key, my_value_unsigned);

}

I have a function get_val_from_db that receives a key name and a key type, with many specializations for each type, including a catch-all template version that merely converts keys names from std::string to const char*, since those can't be done automatically.

Check a live example of this code on compiler explorer, notice that the program crashes when calling the function passing char as a type. This happens because char is not convertible to signed char& (see another compiler explorer example), so when passing char, the best available function to be called is void get_val_from_db(const std::string& key, T& value) which then calls itself, since const char* can be converted to std::string directly. So the call becomes recursive and causes a stack overflow.

I could of course add a new specialization for char, but I want to make the code safer for future developers. I want new parameter types not to be captured by void get_val_from_db(const std::string& key, T& value) and instead get a nice and juicy compilation error. I don't want to remove the function altogether because we need the std::string to const char* conversion to keep the current code working. In summary, how to prevent this implicit conversion from const char* to std::string from happenning?

template <typename T>
void get_val_from_db(const std::string& key, T& value)
{
    // how to prevent key.c_str() from being converted to std::string?
    get_val_from_db(key.c_str(), value);
}

I have a C++ 17 compiler at my disposal.

In general, there are two ways to ensure your function in an overload set doesn't get selected:

1. Declare other functions which win in overload resolution
2. Constrain the overload so it cannot be selected with some arguments
3. Split up the overload set

You've already recognized that you could do 1. by adding:

void get_val_from_db(const char* key, char& value)
{
    std::cout << "Getting value from db with signed char!\n";
}

It's one valid solution, but there are others:

Deleted Function

void get_val_from_db(const std::string& key, char&) = delete;

If this function ever gets called, you will get a compiler error. It will win in overload resolution compared to the template, because it is a non-template.

Constraints

C++17 allows you to constrain functions with SFINAE. std::enable_if is a common tool for that:

template <typename T>
auto get_val_from_db(const std::string& key, T& value)
  -> std::enable_if_t<!std::is_same_v<char, T>>
{
    get_val_from_db(key.c_str(), value);
}

With clang, we get really good diagnostics for std::enable_if:

<source>:31:5: error: no matching function for call to 'get_val_from_db'
    get_val_from_db("my key", my_value_char);
    ^~~~~~~~~~~~~~~
...
<source>:16:6: note: candidate template ignored: requirement '!std::is_same_v<char, char>' was not satisfied [with T = char]
auto get_val_from_db(const std::string& key, T& value)
     ^

Splitting up the Overload Set

You can also solve this issue by separating the "high level" function from some "detail" functions.
We can make it so that the user always calls the function template get_val_from_db, and it will dispatch to the lower-level ones:

// note: prefer std::string_view over const char* or const std::string&
//       (it can be converted from both)
void get_schar_from_db(std::string_view key, signed char& value)
{
    std::cout << "Getting value from db with signed char!\n";
}

void get_uchar_from_db(std::string_view key, unsigned char& value)
{
    std::cout << "Getting value from db with unsigned char!\n";
}

template <typename T>
void get_val_from_db(std::string_view key, T& value)
{
    if constexpr (std::is_same_v<T, signed char>) {
        return get_schar_from_db(key, value);
    }
    else if constexpr (std::is_same_v<T, unsigned char>) {
        return get_uchar_from_db(key, value);
    }
    else {
        // TODO: provide fallback case, dispatch to more special cases, etc.
    }
}

You can also mix this with the Constraints approach above, and you will only have to put a constraint onto the top-level function that is exposed to the user.

> Rename the first two overloads. Replace them with two overloads that call the renamed overloads. Have the third overload use the renamed overloads. Problem solved. –
Sam Varshavchik

You need some conceptual separation between low-level and higher-level routines.

// Low-level routines
void get_val_from_db_lowlevel(const char* key, signed char& value)
{
    std::cout << "Getting value from db with signed char!\n";
}

void get_val_from_db_lowlevel(const char* key, unsigned char& value)
{
    std::cout << "Getting value from db with unsigned char!\n";
}

// Higher-level routines
void get_val_from_db(const char* key, signed char& value)
{
    return get_val_from_db_lowlevel(key, value);
}

void get_val_from_db(const char* key, unsigned char& value)
{
    return get_val_from_db_lowlevel(key, value);
}

// overload to convert first argument from std::string to const char*
template <typename T>
void get_val_from_db(const std::string& key, T& value)
{
    get_val_from_db_lowlevel(key.c_str(), value);
}

You could also stuff the low-level routines into a namespace, or stuff all routines into a class and make the low-level ones private.

> what I want is to get a compilation error if I provide an argument that is not specialized in its own function

You could then SFINAE away the instantiation of the function template in all cases where there exists no overload for void get_val_from_db(const char*, T&):

// convert first argument from std::string to const char*
// only if  "void get_val_from_db(const char*, T&)"  exists
template <class T>
auto get_val_from_db(const std::string& key, T& value) -> 
    std::void_t<decltype(static_cast<void(*)(const char*, T&)>(get_val_from_db))> 
{
    get_val_from_db(key.c_str(), value);
}

Demo

To get a much clearer error message, you could create a type trait to check if an implementation for void get_val_from_db(const char*, T&) exists and use a static_assert instead.

#include <utility>

// helper type trait
template <class T>
struct has_implementation {
    static std::false_type test(...);

    template <class U>
    static auto test(U)
        -> decltype(static_cast<void(*)(const char*, U&)>(get_val_from_db),
                    std::true_type{});

    static constexpr bool value = decltype(test(std::declval<T>()))::value;
};

template <class T>
inline constexpr bool has_implementation_v = has_implementation<T>::value;

template <class T>
void get_val_from_db(const std::string& key, T& value) {
    // very clear error message:
    static_assert(has_implementation_v<T>, "Impl. for T missing");

    get_val_from_db(key.c_str(), value);
}

Demo