如何将不可复制类型的引用传递给 SFINAE“catch-all”重载 function？

Question

I want to handle noncopyable type by reference when SFINAE get unkown input, my code below can't work, is there a better way?

#include <iostream>
#include <functional>

template<typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
void data_type(T const& t) {
    std::cout << "integer" << std::endl;
}

void data_type(...) {
    std::cout << "catch unknown" << std::endl;
}

int main() {
    struct noncopyable_type {
        int i;
        noncopyable_type() {}
        noncopyable_type(const noncopyable_type&) = delete;
    };

    int i;
    noncopyable_type s;

    // first try
    data_type(i);   // ok
    data_type(s);   // error: call to deleted constructor

    // try again
    data_type(std::cref(i)); // ok, but the type is std::reference_wrapper, not integer
    data_type(std::cref(s)); // ok
}

Answer 1

There are probably many ways, this is the first one that came to mind. Live demo

#include <iostream>
#include <functional>

template <typename T, 
          typename = typename std::enable_if<std::is_integral<T>::value>::type>
void data_type(T const& t) {
    std::cout << "integer" << std::endl;
}

template <typename ... T, 
          typename = typename std::enable_if<sizeof...(T)==1>::type>
void data_type(T const&...) {
    std::cout << "unknown" << std::endl;
}

int main() {
    struct noncopyable_type {
        noncopyable_type() {}
        noncopyable_type(const noncopyable_type&) = delete;
    };

    int i;
    noncopyable_type s;

    // first try
    data_type(i);   // ok
    data_type(s);   // ok
}

In C++17 I would just use if constexpr .

Answer 2

We rarely need to use the ... trick anymore. With concepts, we can get the overload resolution behaviour we need without having to play tricks with the parameter declaration clause:

template <typename T>
requires std::integral<T>
void data_type(T const& t) {
    std::cout << "integer" << std::endl;
}

template <typename T>
void data_type(T const& t) {
    std::cout << "unknown" << std::endl;
}

The first overload is more constrained than the second one, so the second one will only be used when the first one is not applicable due to its constraint not being satisfied.

Note that the first overload may equivalently be written like so:

template <std::integral T>
void data_type(T const& t) {
    std::cout << "integer" << std::endl;
}

Answer 3

It's very unclear to me what the actual problem you're trying to solve is, but there's a few possibly better ways to approach this.

With if constexpr

template <typename T>
void data_type(T const&) {
    if constexpr (std::is_integral_v<T>) {
        std::cout << "integral\n";
    } else {
        std::cout << "unknown\n";
    }
}

If (as I suspect) your goal is to not bind a reference to integral types (for whatever reason) you can get fancier with C++20 concepts

template <std::integral T>
void data_type(T) {
    std::cout << "integral\n";
}

template <typename T> requires (!std::integral<T>)
void data_type(T const&) {
    std::cout << "unknown\n";
}