如何使特征接受参数包？

Question

I define some type traits like this:

template <typename T>
struct has_something
{
    static constexpr bool value = false;
};

template <> 
struct has_something<int>
{
    static constexpr bool value = true;
};

template <typename T>
constexpr bool has_something_v = has_something<T>::value;

And a function template which is has_something_v is a requirement for function parameter:

template <typename T, typename = std::enable_if_t<has_something_v<T>>>
void some_function(const T temp)
{
}

When i call it with wrong type:

struct wrong_type
{
};

void f ()
{
    some_function(wrong_type());
}

compiler give me a proper error message:

/tmp/untitled/main.cpp:23: candidate template ignored: requirement 'has_something_v<wrong_type>' was not satisfied [with T = wrong_type]

but when i called with another template function:

template <typename ...T, typename = std::enable_if_t<has_something_v<T...>>>
void some_function(const T... args)
{
    (some_function(args), ...);
}

void f ()
{
    some_function(1, 2, a());
}

compiler give me really bad and confusing error message because i don't have a parameter pack acceptable traits:

Compiler error message

And if i remove std::enable_if from last template function, everything work fine until i send a wrong_type type to function which result is in crashing program.

For parameter pack, i wrote this:

template <typename ...T>
struct has_something
{
    static bool value;

    static constexpr bool c(T... args)
    {
        value = (args && ...);
        return value;
    }
};

template <>
struct has_something<int>
{
    static constexpr bool value = true;
};

template <typename ...T>
const bool has_something_v = has_something<T...>::value;

But it still fail.

How could i write a acceptable parameter pack type traits?

Answer 1

If you want to make the trait accept a parameter pack and it's value be true only when the parameter pack has a single type and that type is int you need to change only little on your code:

#include <iostream>
#include <type_traits>

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

template <> 
struct has_something<int> : std::true_type {};

template <typename... T>
constexpr bool has_something_v = has_something<T...>::value;

int main() {
    std::cout << has_something_v<int>;
    std::cout << has_something_v<double>;    
    std::cout << has_something_v<int,double>;
}

Using std::true_type and std::false_type makes traits a bit shorter to write. I only had to make the trait accept a parameter pack, the specialization can stay the same.

Last but not least you should pick a better name. For example is_one_int would be much better than something .

PS: SFINAE can be used to create compiler errors, but often a simple static_assert is the better choice to get a clean message:

template <typename...T>
void foo(T...args) {
    static_assert( is_one_int_v<T...>, " put nice message here");
}

SFINAE is the tool of choice when you want to disambiguate different overloads, but if a function should simply fail without alternative then a static_assert is simpler.