Przeciążenie funkcji za pomocą szablonów

Próbuję zdefiniować funkcję za pomocą szablonów i chcę, aby nazwa typu była int lub anEnum (określony wyliczenie, które zdefiniowałem). Próbowałem następujące, ale nie powiodło się:

template <int | anEnum T> // or <int T, anEnum T> or <int, anEnum T>
bool isFunction(const T &aVariable){}

Staram się używać szablonów zamiast definiować dwie przeciążone funkcje. Wolałbym, aby funkcja była wywoływana w następujący sposób, bez konieczności rozważania typu przez programistę

isFunction(aVariable) // and not isFunction<int> (aVariable) nor isFunction<anEnum> (aVariable)

Zasadniczo chcę, aby ta funkcja była szablonowana dla typów int i aNum. Szukałem tego, ale nie mogłem znaleźć odpowiedzi. Czego mi brakuje? Dziękuję Ci,

Oprócz odpowiedzi w języku innym niż C ++ 20, jeśli przypadkiem jesteś w stanie użyć C ++ 20 i jego conceptsfunkcji, proponuję ci następującą implementację:

#include <iostream>
#include <concepts>

enum class MyEnum {
    A,
    B,
    C
};

template <typename T>
concept IntegralOrEnum = std::same_as<MyEnum, T> || std::integral<T>;

template <IntegralOrEnum T>
bool isFunction(T const& aVariable) {
    return true;
}

int main() {
    isFunction(MyEnum::A);
    isFunction(3);
    isFunction("my_string"); // error
    return 0;
}

Próbny

AKTUALIZACJA

Według komentarza @RichardSmith , oto bardziej skalowalne i wielokrotnego użytku podejście:

template <typename T, typename ...U>
concept one_of = (std::is_same_v<T, U> || ...);

template <one_of<int, MyEnum> T>
bool isFunction(T const& aVariable) {
    return true;
}

Istnieje kilka sposobów na osiągnięcie tego. Wszystkie wymagają użycia type_traitsnagłówka. Możesz na przykład statycznie potwierdzić dane typy w treści funkcji.

Lub, jeśli trzeba rozważyć tę funkcję wśród innych przeciążeń, można zastosować technikę SFINAE.

template<typename T>
auto isFunction(const T &aVariable) 
  -> std::enable_if_t<std::is_same<T, int>::value || std::is_same<T,anEnum>::value, bool> {
}

Spowoduje to usunięcie funkcji z zestawu przeciążenia przed jej wywołaniem, jeśli typy nie będą pasować. Ale jeśli nie potrzebujesz tego zachowania, statyczne potwierdzenie pozwala na komunikat o błędzie bardziej przyjazny dla programisty.

Co z tym rozwiązaniem? Kod z funkcją zostanie skompilowany, jeśli typ T spełni twoje wymagania. W przeciwnym razie statyczne potwierdzenie nie powiedzie się.

#include <type_traits>
enum anEnum {
    //
};

template <typename T, bool defined = std::is_same<T, int>::value ||
                                     std::is_same<T, anEnum>::value>
bool isFunction(const T& aVariable)
{
    static_assert(defined, "Invalid specialization");

    bool result = false;
    // Put your code here
    return result;
}

Poprawiłem https://stackoverflow.com/a/60271100/12894563 odpowiedź. „Jeśli constexpr” może pomóc w tej sytuacji:

template <typename T>
struct always_false : std::false_type {};

template <typename T>
bool isFunction(const T& aVariable)
{
    if constexpr(std::is_same_v<T, int> || std::is_same_v<T, anEnum>)
    {
        std::cout << "int\n";
        // put your code here
        return true;
    }
    else
    {
        static_assert(always_false<T>::value, "You should declare non-template function or write if constexpr branch for your type");
        return false;
    }
}

bool isFunction(std::string_view)
{
    std::cout << "std::string_view\n";
    return true;
}

int main()
{
    isFunction(std::string_view("1L"));
    isFunction(1);
    //isFunction(1L); // will produce an error message from static_assert
}

isFunction (1L) zawiedzie, ponieważ nie ma przeciążonej funkcji lub gałęzi „if constexpr”.

AKTUALIZACJA: Naprawiono brakujące

template <typename T>
struct always_false : std::false_type {};

https://godbolt.org/z/eh4pVn