What are the rules on using `void` to specialize a template?

user_458742 0
Viewed 135

Here's a stripped down illustration of what I just now wrote in the wild. I wasn't really expecting it to work, but it did.

#include <array>

template <typename T> using Foo = std::array<T,123>;

const int FOO_SIZE = std::tuple_size<Foo<void>>::value;

I wasn't sure using void to specialize Foo would compile, but it did, at least in this case.

I'm not confident that this solution is portable, or if it's just a fluke because the implementation of std::array happens to be compatible with the concept of an array-of-voids, which sounds like nonsense to me.

When can I, and when can I not, use void to specialize a template?

templates c++
2 Answers

I can't find a really convincing specific set of standard wording without reproducing half the standard (:D) but I believe that this is well-defined.

The array constructor requires that T be MoveConstructible or MoveAssignable, and you're not going to be able to instantiate a std::array<void, N>.

But that's fine, because std::tuple_size doesn't need to do that, and it isn't specified to need to do that, and neither thing makes any other specific requirements that would render your code problematic.

However, this does not seem like useful code, and there is no general rule for when void can be used as a template argument. You have to look at the requirements for the specific thing you're using, in the specific context in which you're using it.

user_5606480

It seems on the face of it surprising that this compiles at all, since array of type void are explicitly excluded by the standard (11.3.4: 2 in the N4659 working draft linked) :

An array can be constructed from one of the fundamental types (except void), from a pointer, from a pointer to member, from a class, from an enumeration type, or from another array.

And std::array is typically implemented directly in terms of an array, so one would expect any attempt to use it to fail.

However C++ has generous rules regarding errors in template instantiation that are not directly required in the compilation of the actual usage. In this case, I believe the code is working - and portable - since the calculation of std::tuple_size<Foo<void>>::value does not actually instance Foo<void>, but I would view such as usage as perverse and something you should probably be avoiding since Foo<void> has no validity outside of such exceptions.

Jack_Aidley_15023450
Related