Home/ Questions/Q 7130047
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-28T11:18:30+00:00

C++03 allows to create template class which inheritances from template parameters: // c++03 struct

  • 0

C++03 allows to create template class which inheritances from template parameters:

// c++03 

struct NullType {};

template <class T0, class T1 = NullType, class T2 = NullType>
class Collector : public T0, public T1, public T2
{
};

template <class T0, class T1>
class Collector<T0, T1, NullType> : public T0, public T1
{
};

template <class T0>
class Collector<T0, NullType, NullType> : public T0
{
};

So

typedef Collector<A, B, C> X;

eqeals to

class X: public A, public B, public C {};

C++11 allows do it easier:

// variadic templates - great thing!
template <class ... Classes>
class C11_Collector :
    public Classes ...
{
};

Wrapping collector must wraps template parameters before inheritence:

template <template <class> class Wrap, class T0, class T1 = NullType, class T2 = NullType>
class Wrapping_Collector : public Wrap<T0>, public Wrap<T1>, public Wrap<T2>
{
};

template <template <class> class Wrap, class T0, class T1>
class Wrapping_Collector<Wrap, T0, T1, NullType> : public Wrap<T0>, public Wrap<T1>
{
};

template <template <class> class Wrap, class T0>
class Wrapping_Collector<Wrap, T0, NullType, NullType> : public Wrap<T0>
{
};

So

typedef Wrapping_Collector<W, A, B> X;

eqeals to

class X: public W<A>, public W<B> {};

How implement Wrapping_Collector in more easer way by c++11?

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Is it possible to just enforce Wrap<NullType> to be an empty class? Then you could just directly use

    template <template <typename> class Wrap, typename... Types>
class Wrapping_Collector : public Wrap<Types>... {
   //...
};

    Alternatively, if a double-inheritance chain instead of direct multi-inheritance is fine, you could make Wrapping_Collector<Wrap, A, B...> derive from both Wrapping_Collector<Wrap, B...> and Wrap<A>:

    template <template <typename> class Wrap, typename... Types>
class Wrapping_Collector;

// The normal case
template <template <typename> class Wrap, typename Head, typename... Rest>
class Wrapping_Collector<Wrap, Head, Rest...>
    : public Wrapping_Collector<Wrap, Rest...>, Wrap<Head>
{
    //...
};

// Ignore on NullType
template <template <typename> class Wrap, typename... Rest>
class Wrapping_Collector<Wrap, NullType, Rest...>
    : public Wrapping_Collector<Wrap, Rest...>
{
    //...
};

// Base case
template <template <typename> class Wrap>
class Wrapping_Collector<Wrap> {};
    • 0