Specifying an interface common to class template specializations

Question

Suppose a few class templates specializations have some common public interface. Is it possible to declare it just once?

Example:

// Example for a generator
class G
{
public:
    double generate(int channel);
};

template <typename Generator>
class A
{
public:
    double step();
protected:
    Generator g;
};

template <typename Generator, bool fixedMono>
class B;

template <typename Generator>
class B<Generator,true> : public A<Generator>
{
};

template <typename Generator>
class B<Generator,false> : public A<Generator>
{
public:
    void setNumChannels(int numChannels);
private:
    int numChannels;
};

template<typename Generator>
double B<Generator,true>::step() { return A<Generator>::g.generate(0); }

template<typename Generator>
double B<Generator,false>::step()
{
    double sum = 0;
    for (int i = 0; i < numChannels; ++i)
        sum += A<Generator>::g.generate(i);
    return sum;
}

This fails because the compiler doesn't recognize step being declared in the B specializations (which indeed, it isn't).

In a non-toy example the common interface could be larger than just a single function, and repeating its declaration in all specializations would not be desirable.

Is there good way to specify the common interface just once?

Please note suggestions to refactor the above example so there is no need for the template specializations to have a common interface are irrelevant, unless the refactoring method is one which can always be used to eliminate such interfaces. The question is whether declaring such a common interface just once, in cases where it is needed, is technically possible.

The way I see it, `func` isn't common to both specializations in anything but name. Just declare it in each. You are already try to *define* it for each. — StoryTeller - Unslander Monica, Dec 26 '17 at 10:45
@StoryTeller It is common. The toy example implementation may not reflect it too well. — Danra, Dec 26 '17 at 10:47
The toy example specifies only a common name. If there's common behavior, you can always extract it to other member functions. Define *those* in `A`. Then just use them in each definition of `func` in every `B` specialization. If that still doesn't satisfy... well, a better example is definitely in order. — StoryTeller - Unslander Monica, Dec 26 '17 at 10:49
Instead of defining a step method in A, I would define a templated Step class (in your case by bool and A or Generator) with step method from which B would inherit. — Robert Andrzejuk, Dec 26 '17 at 13:39

score 0 · Answer 1 · answered Dec 26 '17 at 14:47

One improvement would be to use CRTP. On its own it doesn't eliminate the need to declare a member function twice, once in each specialization, but at least the repeating declaration is of the private implementation member function, not of the public interface one, which is only declared once.

// Example for a generator
class G
{
public:
    double generate(int channel);
};

template <typename Derived, typename Generator>
class A
{
public:
    double step() { return static_cast<Derived&>(*this)->stepImpl(); };
protected:
    Generator g;
};

template <typename Generator, bool fixedMono>
class B;

template <typename Generator>
class B<Generator,true> : public A<B<Generator,true>, Generator>
{
private:
    double stepImpl();
    using A<B<Generator,true>, Generator>::g;
};

template <typename Generator>
class B<Generator,false> : public A<B<Generator,false>, Generator>
{
public:
    void setNumChannels(int numChannels);
private:
    double stepImpl();
    int numChannels;
    using A<B<Generator,false>, Generator>::g;
};

template<typename Generator>
double B<Generator,true>::stepImpl() { return g.generate(0); }

template<typename Generator>
double B<Generator,false>::stepImpl()
{
    double sum = 0;
    for (int i = 0; i < numChannels; ++i)
        sum += g.generate(i);
    return sum;
}

score 0 · Answer 2 · answered Dec 26 '17 at 14:59

0

If you want to define a method in a class, you have first to declare it in the same class. Inheritance allow to share behaviour, but here, you reimplement the whole method anyway.

answered Dec 26 '17 at 14:59

Jarod42

203,559
14
181
302

Robert Andrzejuk · Answer 3 · 2017-12-27T15:39:02.237

The main problem is that you cannot achieve this because it is not allowed. A good explianation: https://stackoverflow.com/a/41578586/2504757

Below is another way. Using the Curiously recurring template pattern

Define an empty class for a default template parameter

//==================================================================
class NoNumChannels
{};

Take out the stepping into a class of it's own.

//==================================================================
template< typename Generator, typename NumChannels = NoNumChannels >
class Stepper;

template< typename Generator >
class Stepper< Generator, NoNumChannels > // Specialization case when No Numchannels. Just use the generator.
{
public:
    double step()
    {
        return g.generate( 0 );
    }

protected:
    Generator g;
};

template< typename Generator, typename NumChannels > // Otherwise use a class which has NumChannels
class Stepper
{
public:
    double step()
    {
        double sum = 0;
        for (int i = 0; i < (static_cast<NumChannels&>(*this).numChannels_v()); ++i) //Use Curiously recurring template pattern to access num of channels
            sum += g.generate( i );
        return sum;
    }

protected:
    Generator g;
};

Definition of B is slightly modified. For case where it doesn't have NumChannels just inherit from Stepper with Generator. Otherwise inherit from Stepper with Generator and self.

//==================================================================
template< typename Generator, bool fixedMono >
class B;

template< typename Generator >
class B< Generator, true > : public Stepper< Generator >
{};

template< typename Generator >
class B< Generator, false > : public Stepper< Generator, B< Generator, false > >
{
public:
    void setNumChannels( int numChannels );
    int numChannels_v();
private:
    int numChannels;
};

Specifying an interface common to class template specializations

3 Answers3