C++17, ueber Tuple UND Parameter-Pack iterieren?

[cppbert (Gast)]

Ich versuche gerade den Wert N aus einem Parameter-Pack mit einer 
statischen Methode in einem Tuple an Stelle N aufzurufen (siehe 
many::xyz) - ich habe aber keine Idee wie ich in C++17 elegant das 
Mapping mache

jemand einen Tip?

gcc-godbolt: https://gcc.godbolt.org/z/K4vE4E

#include <tuple>

template<typename ValueType>
struct single
{
  static int xyz(const ValueType& value_)
  {
    // nur als Beispiel, ich habe
    // Spezialisierungen fuer Typen die
    // hier Berechnungen,usw. machen
    return sizeof(value_);
  }
};

template <typename... ValueType>
class many
{
public:
    using Singles = std::tuple<single<ValueType>...>;

    static int xyz( const ValueType&... value_ )
    {
        int result = 0;
        //for(...)
        //  result += Singles[I]::xyz(value_[I])

        //Ich vermute das ich was
        //mit std::integer_sequence machen muss

        return result;
    }
};

using Many = many<int,float,short/*,std::string,....*/>;

int main()
{
  int x = Many::xyz(1,3.2f,2/*,"hallo",...*/);
  // sollte auf meiner Platform gerade 4+4+2 Ergeben
  return 0;
}

in einem anderen Test habe ich die Values
direkt mit in dem single, statefull mit Members, nix statisch

   int xyz() const
   {
     auto sum = []( auto&... single ) { return ( single.xyz() + ... ); };
     auto result = std::apply( sum, m_singles );
       return result;
    }

funktioniert auch aber ich moechte das single eigentlich stateless und 
voll statisch bekommen

[cppbert (Gast)]

mir ist eine mögliche Vereinfachung aufgefallen

ich kann könnte auf tuple komplett verzichten
weil ich ja lokal einfach eine template-Instanz von meinem single 
erstellen kann

das macht es einfacher aber ich hab noch keine Idee wie man das jetzt 
genau macht

template <typename... ValueType>
class many
{
public:
    static int xyz( const ValueType&... value_ )
    {
        int result = 0;
        //for(I ...)
        //  result += single<ValueType[I]>::xyz(value_[I])
        return result;
    }
};

[cppbert (Gast)]

sieht schon mal besser aus

template <typename... ValueType>
class many
{
public:
    static int xyz( const ValueType&... value_ )
    {
        return ( single<ValueType>::xyz( value_ ) + ... );
    }
};

[cppbert (Gast)]

Alles läuft und ist noch viel kleiner und einfacher als ich gedacht 
hätte - Danke fürs Lesen

[Hans-Georg L. (h-g-l)]

cppbert schrieb:
> Alles läuft und ist noch viel kleiner und einfacher als ich gedacht
> hätte - Danke fürs Lesen

Wenn ich dich richtig verstanden habe möchtest du im Endergebnis einen 
Varadic adder haben ?

Probier das mal aus ...

template<typename ... Args>
constexpr auto add(Args ... args ) {
           return (... + args);
};

[cppbert3 (Gast)]

Hans-Georg L. schrieb:
> cppbert schrieb:
>> Alles läuft und ist noch viel kleiner und einfacher als ich gedacht
>> hätte - Danke fürs Lesen
>
> Wenn ich dich richtig verstanden habe möchtest du im Endergebnis einen
> Varadic adder haben ?
> Probier das mal aus ...
> template<typename ... Args>
> constexpr auto add(Args ... args ) {
>            return (... + args);
> };

Nicht ganz, mein letzter Quelltextpost ist das was ich wollte, dein 
Beispiel passt aber zu meiner vorherigen Anforderung , Danke