Variadic variadic Vorlage Vorlage Parameter

Question

Gibt es eine einfache Möglichkeit, variadic variadic Vorlage Vorlage Parameter zu haben. Zum Beispiel betrachten Sie die folgende Funktion Signatur

template<template<typename,size_t...> class Pack, 
    typename T, size_t ... Args> 
void foo(const Pack<T,Args...>& a); 

Wenn wir zwei Pack s übergeben wollen wir jetzt tun müssen, um eine Überlast

template<template<typename,size_t...> class Pack, 
    typename T, size_t ... Args0, size_t ... Args1> 
void foo(const Pack<T,Args0...>& a, const Pack<T,Args1...>& b); 

Was nun, wenn wir eine variable Anzahl von Objekten von Pack übergeben möchten mit verschiedenen variadischen Parametern z Args0...,Args1...,Args2....

Also habe ich überlegt, ob es eine praktische Möglichkeit gibt, etwas in der Art zu tun (das Folgende ist sicherlich eine Skizzenrepräsentation).

template<template<typename,size_t...> ... class Pack, typename T,...> 
void foo(const Pack<T,...> ... packs); 

Answer 1

Ich würde nur eine normale variadische Vorlage verwenden:

template<typename... Ts> 
void foo(const Ts&... packs) { 

} 

Dann einen Zug schreiben die Art und size_t s zu extrahieren. Sie könnten leicht einige Helper-Alias-Vorlagen hinzufügen, um das zu tun, was Sie wollen.

template <typename T> struct extract_args; 

template <template <typename, size_t...> class Pack, typename T, size_t... Args> 
struct extract_args<Pack<T,Args...>> { 
    using type = T; 
    using args = std::index_sequence<Args...>; 
}; 

dann innerhalb foo können Sie die Argumente extrahieren und sie verwenden, aber wie Sie. Zum Beispiel bekommen ein std::tuple enthält alle T s aus den Packungen:

using all_ts = std::tuple<typename extract_args<Ts>::type...>; 

Answer 2

Ich schlage vor, Sie Pack Argumente rekursiv zu verwalten, auf diese Weise

#include <array> 

template <typename T, std::size_t ... Args> 
struct testS 
{ }; 

void foo() 
{ /* terminal iteration */ } 

template <template <typename, std::size_t...> class Pack, 
      typename T, std::size_t ... Args, typename ... Packs> 
void foo (const Pack<T, Args...> pack0, Packs ... packs) 
{ 
    // do something with pack0 

    foo(packs...); 
} 

int main() 
{ 
    foo(testS<int>{}, std::array<long, 5U>{}, testS<char, 7U, 9U, 11U>{}); 

    return 0; 
} 

--- Bearbeiten ---

Geändertes Beispiel, um die Verwendung mit verschiedenen Typen und einer variablen Anzahl von std::size_t Vorlagenparametern anzuzeigen.