Creating multiple class implemetations based on template parameter

Question

I have a templated class G:

template
class G {}

And it's so happens that I need 2 implementations based on that int I

If it was a single value, I would always be able to do:

template<>
class G
{
    /*Implementation for that I*/
}

If I had single condition, which shows to use implementation_1 if true and implementation_2 if false, I could've used advice given here

But, my situation is more general.

Let's say I defined conditions on I for each implementation:

template
constexpr bool Condition_1 = /*whatever*/;

template
constexpr bool Condition_2 = /*whatever_v2*/;

This allows for easy readability and expansion as needed
And if I get an error due to none or multiple of conditions applying for specific I when called in program, I'm fine with that

Obvious choice is to use std::enable_if_t

template>
        >
class G
{
    /*Implementation based on Condition_1*/
}

template>
        >
class G
{
    /*Implementation based on Condition_2*/
}

But this causes an error

template parameter ‘typename std::enable_if, void>::type ’|

redeclared here as ‘typename std::enable_if, void>::type ’|

Where have I made mistake and how do I fix that?

user_817643 · Answer

Your mistake is that you didn't adjust the primary template to use the idiom correctly. If you want to add those enable_if's that resolve to void, the primary template declaration needs a type parameter in that place:

template
class G; // Or static_assert in the definition. Whichever flavor you prefer.

template
class G< I, enable_if_t> >
{
    /*Implementation based on Condition_1*/
};

template
class G< I, enable_if_t> >
{
    /*Implementation based on Condition_2*/
};

Note: the default argument must be void for your specializations with the condition to match. This will of course result in an error when both conditions hold, but you did assert that's fine with you, so there you go.

user_412080 · Answer

You don't need std::enable_if for this problem. Since your conditions are independent they should initialize a different template parameter:

template, bool C2 = Condition_2>
struct G;

// Specializations for different conditions.
template struct G { /*...*/ };
template struct G { /*...*/ };
template struct G { /*...*/ };
template struct G { /*...*/ };

Alternatively, you can compose conditions into one parameter:

template | Condition_2 * 2)> struct G; // Specializations for different conditions. template struct G { /*...*/ }; template struct G { /*...*/ }; template struct G { /*...*/ }; template struct G : G { /*...*/ }; // Same as G.

Creating multiple class implemetations based on template parameter

2 Answers