En aras de la claridad, he eliminado cosas como el constructor y destructor, etc., de abajo, donde no agregan nada a la pregunta. Tengo una clase base que se usa para crear un ancestro común para una clase de plantilla derivada.

class PeripheralSystemBase {
public:
    virtual void someFunctionThatsCommonToAllPeripherals() {}
};

template <class T, uint32_t numPeripherals = 1>
class PeripheralSystem : public PeripheralSystemBase {
public:
    PeripheralSystem() : vec(T) {}
    std::vector<T> vec;  // different types of T is the reason why I need to template this class
};

// A & B declaration & definition are irrelevant here
class A{};
class B{};

// There are multiple different derived variants of PeripheralSystem
// At the moment, each has different template parameters

template <uint32_t customisableParam1>
class DerivedSystem1 : public PeripheralSystem<A, 1> {
public:
    DerivedSystem1() : PeripheralSystem<A, 1>() {}
};

template <uint32_t customisableParam1, uint8_t customisableParam2>
class DerivedSystem2 : public PeripheralSystem<B, 1> {
public:
    DerivedSystem2() : PeripheralSystem<B, 1>() {/*maybe use customisableParam2 here */}
};

Así que ahora tengo 2 clases de plantillas, cada una derivada de la misma clase ancestral, una que contiene un vector que contiene el tipo A, la otra del tipo B; cada uno tiene diferentes parámetros de plantilla. Hasta aquí todo bien.

Ahora para la pregunta. Me gustaría poder crear una plantilla de contenedor que no contenga ninguna, una o más de las versiones derivadas de PeripheralSystem dentro de ella y creo que puedo usar plantillas variadas para hacer esto, pero me he quedado un poco atascado la sintaxis del último día más o menos. En el momento de la compilación, me gustaría poder crear una instancia de la clase contenedor. Quizás algo como:

template< template<typename ...> class args...>
class ContainerClass {
  public:
    ContainerClass() : container({args}) {}
    std::vector<PeripheralSystem> container;
};

// possible usage
ContainerClass<DerivedSystem1<1>> cc1;
ContainerClass<DerivedSystem2<2, 3>> cc2;
ContainerClass<DerivedSystem1<1>, DerivedSystem2<2, 3>> cc3;

Sé que el formato variadic que estoy usando no es correcto, ya que obtengo:

error: esperado ',' o '>' en template-parameter-list template <template class args ...>>

Lo que intento decirle al compilador es que quiero proporcionar un número variable de parámetros de tipo plantilla a la plantilla, cada uno de los cuales tiene un número variable de parámetros de plantilla. ¿Puedo hacer esto con plantillas variadas por favor? ¿Alguna sugerencia sobre la sintaxis correcta por favor?