C++17: Templates, Index zu meinem variadic Parameter unpacking

[cppbert (Gast)]

Platform: C++17, VS2017 (und GCC)

zum Kompilieren: https://godbolt.org/z/55Yjd578K

Ich hab versucht ein ultra abgespecktes Beispiel zu machen - so
nicht mehr ganz sinnvoll - aber es enthält alle Stellen die für mich 
wichtig
sind

Problem: in der Result::fetch fehlt mir der Index 
[1-sizeof...(OutputTypes)]

hat jemand eine Idee wie man das lösen kann?

Da soll am Ende ein typesafer-rer SQLite Wrapper werden

template<typename T>
struct Converter;

template<>
struct Converter<int>
{
    static int value(int index_) { return 12345; /* hier wird normalerweise mit index_ und mehr gearbeitet */ };
};

template<>
struct Converter<float>
{
    static float value(int index_) { return 543.12f; /* hier wird normalerweise mit index_ und mehr gearbeitet */ };
};

// ... es gibt viele weitere nicht primitiv-Typ Spezialisierungen

template<typename... OutputTypes>
struct Result
{
    template<typename Output>
    void fetch(Output& output_)
    {
        // hier ist normlerweise eine Schleife
        // mit Abbruchbedinung - und mehr Kontext

        output_ = { Converter<OutputTypes>::value(0/*SOLL: 1-n*/)..., };
    }
};

int main()
{
    using MyResult = Result<int, float, int>;

    // in MyResult::fetch sollte das out_first_ assignment jetzt so aufgeloest werden
    //    out_first_ = { Converter<int>::value(1), 
    //                   Converter<float>::value(2), 
    //                   Converter<int>::value(3) };

    MyResult my_result;

    struct Output
    {
        int a;
        float b;
        int c;
    };

    Output output;
    my_result.fetch(output);

    return 0;
}

[Al Fine (Gast)]

Along the lines

template<typename Output>
void fetch(Output& output_)
{
   int index = 1;
   output_ = { Converter<OutputTypes>::value(index++)..., };
}

[cppbert (Gast)]

ich mache das Folding Zeug immer noch zu selten - ist ja nur ein 
Parameter d.h. ganz normal mit Variable

und ich habe jetzt auch eine std::index_sequence Lösung die auch mit 
Template-Parameter funktioniert - falls ich das dann doch mal brauche

[Al Fine (Gast)]

cppbert schrieb:
> und ich habe jetzt auch eine std::index_sequence Lösung die auch mit
> Template-Parameter funktioniert - falls ich das dann doch mal brauche

Ja, richrig. index_sequence war mir jetzt zu frickelig.

[cppbert3 (Gast)]

Al Fine schrieb:
> cppbert schrieb:
>
>> und ich habe jetzt auch eine std::index_sequence Lösung die auch mit
>> Template-Parameter funktioniert - falls ich das dann doch mal brauche
>
> Ja, richrig. index_sequence war mir jetzt zu frickelig.

ja das war ein bisschen frickelig

[Al Fine (Gast)]

cppbert3 schrieb:
> ja das war ein bisschen frickelig

Aber wahrscheinlich immer noch besser als die Old-School iteration mit 
einem Hilfs-template.

[M.K. B. (mkbit)]

Al Fine schrieb:
> Along the lines
>
>

> template<typename Output>
> void fetch(Output& output_)
> {
>    int index = 1;
>    output_ = { Converter<OutputTypes>::value(index++)..., };
> }
>

Ich bin mir hier nicht sicher, ob die Reihenfolge der Ausführung von ++ 
beim Kommaoperator mit folding hier garantiert ist. Sonst könnte man auf 
manchen Compilern falsche Werte bekommen.

[Al Fine (Gast)]

M.K. B. schrieb:
> Ich bin mir hier nicht sicher, ob die Reihenfolge der Ausführung von ++
> beim Kommaoperator mit folding hier garantiert ist.

Das Komma ist kein Operator. Das ist das Trennzeichen einer "list 
initialization". Ich glaube das Komma ist immer sequenzierend - außer 
bei Funktionsparametern.

[Al Fine (Gast)]

Essex schrieb im Beitrag #6739470:
> Wie kann man sich mit einer Sprache und solchen Fummeligkeiten nur so
> abplagen?

Ich denke, man braucht - je nach Calling-Convention - weniger Stack, 
wenn man die Werte für die Argumente in beliebiger Reihenfolge berechnen 
kann.

[Wilhelm M. (wimalopaan)]

Falls Du den Index als compiletime-const brauchst:

    template<typename Output>
    void fetch(Output& output_)
    {
        auto r = []<auto... II>(std::index_sequence<II...>){
            return Output{Converter<OutputTypes>::value(II)...,};
        }(std::make_index_sequence<sizeof...(OutputTypes)>{});
        output_ = r;
    }

[Wilhelm M. (wimalopaan)]

Sorry, war nicht genau das, was Du wolltest:

    static inline constexpr size_t size() {
        return sizeof...(OutputTypes);
    }
    template<typename Output>
    void fetch(Output& output_)
    {
        output_ = []<auto... II>(std::index_sequence<II...>){
            return Output{Converter<OutputTypes>::value(II + 1)...,};
        }(std::make_index_sequence<size()>{});
    }

[Al Fine (Gast)]

Wilhelm M. schrieb:
>         output_ = []<auto... II>(std::index_sequence<II...>){
>             return Output{Converter<OutputTypes>::value(II + 1)...,};
>         }(std::make_index_sequence<size()>{});

So ist das c++20, oder?

[cppbert3 (Gast)]

> Wie kann man sich mit einer Sprache und solchen Fummeligkeiten nur so
> abplagen?

wie kommst du darauf das sich irgendwer abplagt, die non template 
variante hab ich in 5min komplett fertig geschrieben, aber mit der 
template lib bekomme ich das viel kürzer, typesafe und generisch 
erweiterbar, dafür nehme ich dann schon ein bisschen arbeit in kauf, 
klar sieht C, C# und Python einfacher aus aber damit ists dann nicht 
typesafe UND einfach zu nutzen und der End-Anwender sieht diesen Code ja 
auch gar nicht

[Wilhelm M. (wimalopaan)]

cppbert3 schrieb:
>> Wie kann man sich mit einer Sprache und solchen Fummeligkeiten nur so
>> abplagen?
>
> wie kommst du darauf das sich irgendwer abplagt,

Für manche Leute ist eben alles ein "int", und wenn nicht, dann ist es 
ein "string". Das man Datentypen zur Compilezeit ausrechnen lassen kann, 
ist dann unvorstellbar ...