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

Gast #6566837
Lesenswert?

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
1
#include <tuple>
2

3
template<typename ValueType>
4
struct single
5
{
6
  static int xyz(const ValueType& value_)
7
  {
8
    // nur als Beispiel, ich habe
9
    // Spezialisierungen fuer Typen die
10
    // hier Berechnungen,usw. machen
11
    return sizeof(value_);
12
  }
13
};
14

15
template <typename... ValueType>
16
class many
17
{
18
public:
19
    using Singles = std::tuple<single<ValueType>...>;
20

21
    static int xyz( const ValueType&... value_ )
22
    {
23
        int result = 0;
24
        //for(...)
25
        //  result += Singles[I]::xyz(value_[I])
26

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

30
        return result;
31
    }
32
};
33

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

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

in einem anderen Test habe ich die Values
direkt mit in dem single, statefull mit Members, nix statisch
1
   int xyz() const
2
   {
3
     auto sum = []( auto&... single ) { return ( single.xyz() + ... ); };
4
     auto result = std::apply( sum, m_singles );
5
       return result;
6
    }

funktioniert auch aber ich moechte das single eigentlich stateless und 
voll statisch bekommen
Gast #6567337
Lesenswert?

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
1
template <typename... ValueType>
2
class many
3
{
4
public:
5
    static int xyz( const ValueType&... value_ )
6
    {
7
        int result = 0;
8
        //for(I ...)
9
        //  result += single<ValueType[I]>::xyz(value_[I])
10
        return result;
11
    }
12
};
Gast #6567341
Lesenswert?

sieht schon mal besser aus
1
template <typename... ValueType>
2
class many
3
{
4
public:
5
    static int xyz( const ValueType&... value_ )
6
    {
7
        return ( single<ValueType>::xyz( value_ ) + ... );
8
    }
9
};
Gast #6568212
Lesenswert?

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

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

oder

Mit Google-Account einloggen

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren