Use SFINAE to enable a partial specialisation based on the size of a pack

Question

I'm trying to make a template that works with characters, at compile time. In this instance I want to impose a constraint that there must always be an exact multiple of some number of characters given.

In the case where there isn't an exact match I want to pad them with 0 at the head of the pack.

(As an aside the motivation behind this is wanting to (at compile time, as part of a bigger problem) add support for mapping binary and hexadecimal literals on to std::array<unsigned char, N>, this works beautifully except for padding out the things which aren't a multiple of bytes).

Here's a simplified example of what I'm trying to do to get the padding to work:

// Thingy operates on N*4 chars - if that's not met use inheritance to 0 pad until it is met.
template<char ...Args>
struct thingy : thingy<0, Args...> {
    // All we do here is recursively add one more 0 via inheritance until the N*4 rule is met
};

// This specialisation does the real work, N=1 case only
template<char a, char b, char c, char d>
struct thingy<a,b,c,d> {
    enum { value = (a << 24) | (b << 16) | (c << 8) | d }; 
};

// This handles chunking the N*4 things into N cases of work. Does work along the way, only allowed for exact N*4 after padding has happened.
template <char a, char b, char c, char d, char ...Args>
struct thingy<a,b,c,d,Args...> : thingy<a,b,c,d> {
    static_assert(sizeof...(Args) % 4 == 0); // PROBLEM: this is a we're a better match than the template that pads things, how do we stop that?
    // Do something with the value we just got and/or the tail as needed
    typedef thingy<a,b,c,d> head;
    typedef thingy<Args...> tail;
};

int main() {
    thingy<1,1,1,1,1>(); // This should be equivalent to writing thingy<0,0,0,1,1,1,1,1>()
}

This hits my static_assert. The issue is we always match the wrong specialisation here, which I was expecting because it's more specialised.

So I looked around and found some examples of the same problem for a function, but as far as I can see neither of those are applicable here.

I tried a few more things out, none of which worked quite how I'd hoped, first up was naively enable_if on sizeof...(Args) exactly where I wanted it:

template <char a, char b, char c, char d, typename std::enable_if<sizeof...(Args) % 4 == 0, char>::type ...Args>
struct thingy<a,b,c,d,Args...> : thingy<a,b,c,d> {
    // ...
};

This isn't legal though as far as I can tell and certainly doesn't work on my compilers - at the point where we need to query sizeof...(Args) the Args doesn't yet exist.

We can't legally add another template argument after the pack either as far as I can tell, this also failed:

template <char a, char b, char c, char d, char ...Args, typename std::enable_if<sizeof...(Args) % 4 == 0, int>::type=0>
struct thingy<a,b,c,d,Args...> : thingy<a,b,c,d> {
    // ...
};

with an error:

pad_params_try3.cc:17:8: error: default template arguments may not be used in partial specializations

I also tried SFINAE in the inheritance itself, but that doesn't seem to be a legitimate place to do it:

template <char a, char b, char c, char d, char ...Args>
struct thingy<a,b,c,d,Args...> : std::enable_if<sizeof...(Args) % 4 == 0, thingy<a,b,c,d>>::type {
    // ...
};

In that we hit both the static_assert and an failure which is an error in enable_if.

pad_params_try4.cc:17:8: error: no type named 'type' in 'struct std::enable_if<false, thingy<'\001', '\001', '\001', '\001'> >'
 struct thingy<a,b,c,d,Args...> : std::enable_if<sizeof...(Args) % 4 == 0, thingy<a,b,c,d>>::type {
        ^~~~~~~~~~~~~~~~~~~~~~~
pad_params_try4.cc:18:5: error: static assertion failed
     static_assert(sizeof...(Args) % 4 == 0);

As far as I can make out from reading around a bit more this might even be considered a defect, but that doesn't help me out much right now.

How can I work around this, with what I've got in C++14, gcc 6.x? Is there a simpler option than going back to the drawing board completely?

You can work around the problem with a helper function that is called with the calculated value you want to SFINAE on before the actual pack. Let me write up an answer. — Max Langhof, Feb 15 '19 at 12:19

jrok · Accepted Answer · 2019-02-15T12:44:43.313

How about a slightly different approach with multiple inheritance and an intermediate helper struct that does the padding?

// This handles chunking the N*4 things into N cases of work. Does work along the way, only allowed for exact N*4 after padding has happened.
template <char a, char b, char c, char d, char... Args>
struct thingy_impl : thingy_impl<a, b, c, d>, thingy_impl<Args...> {
    static_assert(sizeof...(Args) % 4 == 0);
    // Do something with the value we just got and/or the tail as needed
    typedef thingy_impl<a,b,c,d> head;
    typedef thingy_impl<Args...> tail;
};

template<char a, char b, char c, char d>
struct thingy_impl<a,b,c,d> {
    enum { value = (a << 24) | (b << 16) | (c << 8) | d }; 
};

template<int REMAINDER, char... Args>
struct padding;

template<char... Args>
struct padding<0,Args...> { using type = thingy_impl<Args...>; };

template<char... Args>
struct padding<1,Args...> { using type = thingy_impl<0,0,0,Args...>; };

template<char... Args>
struct padding<2,Args...> { using type = thingy_impl<0,0,Args...>; };

template<char... Args>
struct padding<3,Args...> { using type = thingy_impl<0,Args...>; };

template<char... Args>
struct thingy : padding<sizeof...(Args) % 4, Args...>::type { };

int main() {
    thingy<1,1,1,1,1>(); // This should be equivalent to writing thingy<0,0,0,1,1,1,1,1>()
}

Demo, with a diagnostic output.

Can you not simplify that to avoid explicitly handling the 1,2,3 padding cases individually? I.e. padding<0, Args...> and padding would be sufficient. — Flexo, Feb 15 '19 at 14:50
@Flexo: Possible: `template struct padding : padding<(REMAINDER + 1) % 4, 0, Args...> {};` + current specialization for `0`. — Jarod42, Feb 15 '19 at 19:54
This was the solution I went with with an adaption to only handle the `0` and `N` cases for padding as it allowed me to generalise the padding requirements further using some traits — Flexo, Feb 22 '19 at 19:59

Max Langhof · Answer 2 · 2019-02-15T12:53:39.677

First of all, a simple solution in C++ 17, using a recursive if constexpr helper function to do the padding for you:

template<char ... Args>
auto getThingyPadded()
{
    if constexpr (sizeof...(Args) % 4 != 0)
        return getThingyPadded<0, Args...>();
    else
        return thingy<Args...>{};
}

To make this C++14, we need to use SFINAE instead of if constexpr. We can add a call that computes sizeof...(Args) for us to circumvent the problems you were describing:

template<bool B, class U = void>
using enableIfT = typename std::enable_if<B, U>::type;

template<std::size_t N, enableIfT<(N % 4 == 0)>* = nullptr, char ... Args>
auto getThingyPaddedHelper()
{
    return thingy<Args...>{};
}

template<std::size_t N, enableIfT<(N % 4 != 0)>* = nullptr, char ... Args>
auto getThingyPaddedHelper()
{
    return getThingyPaddedHelper<N+1, nullptr, 0, Args...>();
}

template<char ... Args>
auto getThingyPadded()
{
    return getThingyPaddedHelper<sizeof...(Args), nullptr, Args...>();
}

Demo!

score 1 · Answer 3 · answered Feb 15 '19 at 15:36

I would get rid of list with head/tail and use std::tuple, resulting to:

// No variadic here
template <char a, char b, char c, char d>
struct thingy {
    enum { value = (a << 24) | (b << 16) | (c << 8) | d }; 
};

template <typename Seq, char... Cs>
struct thingies_impl;

template <std::size_t ...Is, char... Cs>
struct thingies_impl<std::index_sequence<Is...>, Cs...>
{
private:
    static constexpr char get(std::size_t n)
    {
        constexpr char cs[] = {Cs...};
        constexpr std::size_t paddingSize = (4 - (sizeof...(Cs) % 4)) % 4;
        return (n < paddingSize) ? '\0' : cs[n - paddingSize];
    }

public:
    using type = std::tuple<thingy<get(4 * Is),
                                   get(4 * Is + 1),
                                   get(4 * Is + 2),
                                   get(4 * Is + 3)>...>;  
};

template <char... Cs>
using thingies = thingies_impl<std::make_index_sequence<(sizeof...(Cs) + 3) / 4>, Cs...>;

Demo

Yet another way the unpack operator can be used that I totally missed — Flexo, Feb 15 '19 at 19:30

max66 · Answer 4 · 2019-02-15T16:26:19.323

Another multiple inheritance approach (with a correction and a simplification from Jarod42 (thanks!)).

#include <utility>

template <char a, char b, char c, char d, char ... Args>
struct t_base : public t_base<Args...>
 {
   typedef t_base<a,b,c,d> head;
   typedef t_base<Args...> tail;
 };

template <char a, char b, char c, char d>
struct t_base<a, b, c, d>
 { enum { value = (a << 24) | (b << 16) | (c << 8) | d }; };


template <typename, typename>
struct t_helper;

template <std::size_t ... Is, char ... Cs>
struct t_helper<std::index_sequence<Is...>,
                std::integer_sequence<char, Cs...>>
   : public t_base<(Is, '0')..., Cs...>
 { };


template <char ... Cs>
struct thingy :
   public t_helper<std::make_index_sequence<(4u - sizeof...(Cs) % 4u) % 4u>,
                   std::integer_sequence<char, Cs...>>
 { };


int main ()
 {
 }

Use SFINAE to enable a partial specialisation based on the size of a pack

4 Answers4