Enforce template type through static_assert

Question

I'm trying to understand the usefulness of static_assert, and I want to know if it can help me in enforcing a design, and if so, how.

I have a general template class that hides its own implementation inside another template class which is partially specialized based on the size of the template type. Here's a brief outline of this design:

template <class T, size_t S = sizeof(T)>
struct Helper;

template <class T>
struct Helper<T, sizeof(long)>
{
    static T bar();
};

// ... other specializations ...

template <class T>
class Foo
{
public:

    T bar()
    {
        return Helper<T>::bar();
    }
};

Foo is only supported if size of T is supported by a specialization of Helper. For example, Foo<long> and Foo<unsigned long> are both supported. However, suppose the user tries to construct a Foo<bool>. Normally, this would generate errors because the specialization of Helper for bool isn't defined, which is intended behaviour.

Is there any way to use static_assert in this design to provide more helpful errors to the user of this interface?

Additionally, I'd like to also restric the user from using a specific type, even though the size might be correct. For example, Foo<float> shouldn't be allowed. Right now, the only way I know of enforcing this is through a bold comment in the documentation. :)

Answer 1

If it can only work for a specialization of the template class, then have the default template class raise a static assert:

template <class T, size_t S = sizeof(T)>
struct Helper
{
   static_assert(sizeof(T) == -1, "You have to have a specialization for Helper!" );
}

The default template class will only be chosen if there isn't a better specialization, therefore the assert will be risen.

You can use the same technique to disallow types, but you'll need another template parameter that will be used for the static assert check.

template <class T, class G = T, size_t S = sizeof(T)>
struct Helper
{
   static_assert(sizeof(G) == -1, "You have to have a specialization for Helper!" );
}

template <class G>
struct Helper<float,G>
{
   static_assert(sizeof(G) == -1, "You can't use float !" );
}

template <>
struct Helper<int>
{
 //This is a good specialization
};

Then you can try it with these variables:

Helper<bool> a;  //"You have to have a specialization for Helper!"
Helper<float> b; //"You can't use float !"
Helper<int> c;   //compiles OK

Answer 2

http://en.cppreference.com/w/cpp/header/type_traits

std::is_base_of and std::is_convertible could help with your first issue and as for the second,

static_assert(!std::is_same<float,T>(),"type can't be float");

hopefully this helps someone else who stumbles upon this question, assuming OP probably found an answer in the 4 years since it was asked :)

Answer 3

I figured out a better solution for this problem by combining the answers and comments here.

I can define a static type checker like so:

template <class A, class B>
struct CheckTypes
{
    static const bool value = false;
};

template <class A>
struct CheckTypes<A, A>
{
    static const bool value = true;
};

Not sure if such a struct already exists in the standard library. Anyways, then in Foo, I can check for types and sizes using:

static_assert((sizeof(T) == sizeof(long) || sizeof(T) == sizeof(int)) && !CheckTypes<T, float>::value, "Error!");