C++17, Sind Multi Parameter Packs möglich?

[cppbert3 (Gast)]

zur Reduzierung von Boilerplate Code um mich an eine "C-Artige" 
Schnittstelle zu adaptieren die schon existiert implementiere
für jede Klasse die ich anbinden möchte ein Template was das 
durchreichen von Parametern stark vereinfacht und dabei noch 
Kontext-Keys (für ein Storage-System) mitliefert - jetzt wollte ich den 
immer (bis auf die Keys) gleiche Code aus den InnerEvalAndStore mit 
einem allgemeinen OuterEvalAndStore Template ersetzen scheitere aber 
aber daran die Varianten Anzahl an Keys und die Variante Anzahl an 
Methode-Paramater miteinander zu kombinieren

hat jemand eine Idee wie man so was machen könnte?

hier mein etwas längerer Beispiel-Code - Sorry :{

gcc.godbolt.org: https://gcc.godbolt.org/z/9ceG1z

#include <string>

// "C-Artige"-Schnittstelle an die ich mich adaptieren will

void eval_func( double target_, double value_ ){}
void eval_func( int target_, int value_ ){}
void eval_func( const std::string& target_, const char* value_ ){}

void store_func_A( int key1_, const std::string& key2_, double value_ ){}
void store_func_B( int key1_, const std::string& key2_, const std::string& value_ ){}
void store_func_C( double key1_, int value_ ){}

/*
// wie kann man multi parameter packs realisieren?

template <auto StoreFunc, typename ValueType, typename... Values, typename... Keys>
inline void OuterEvalAndStore(ValueType& target_, Values&&... values_, Keys&&... keys_)
{
    // hier passiert noch viel mehr im Original
    eval_func(target_, std::forward<Values>(values_)...);
    StoreFunc(std::forward<Keys>(keys_)..., target_);
}
*/

class Test1
{
private:
    template <auto StoreFunc, typename ValueType, typename... Values>
    inline void InnerEvalAndStore( ValueType& target_, Values&&... values_ )
    {
        // hier passiert noch viel mehr im Original
        eval_func( target_, std::forward<Values>( values_ )... );
        StoreFunc( m_key1, m_key2, target_ ); // key1, key2

        //OuterEvalAndStore(target_, {values_}, {m_key1, m_key2});
    }

public:
    void setA( double A_ ){ InnerEvalAndStore<store_func_A>( m_A, A_ ); }
    void setB( const char* B_ ){ InnerEvalAndStore<store_func_B>( m_B, B_ ); }
    //...

private:
    //keys (ueber ctor gesetzt)
    int m_key1{};
    std::string m_key2;

    //targets
    double m_A{};
    std::string m_B;
    //...
};

class Test2
{
private:
    template <auto StoreFunc, typename ValueType, typename... Values>
    inline void InnerEvalAndStore( ValueType& target_, Values&&... values_ )
    {
        // hier passiert noch viel mehr im Original
        eval_func( target_, std::forward<Values>( values_ )... );
        StoreFunc( m_key1, target_ ); // key1

        //OuterEvalAndStore(target_, {values_}, {m_key1});
    }

public:
    void setC( int C_ ){ InnerEvalAndStore<store_func_C>( m_C, C_ ); }
    //...

private:
    //keys (ueber ctor gesetzt)
    double m_key1{};

    //targets
    int m_C{};
    //...
};

int main()
{
    Test1 t1;
    t1.setA( 23.0 );
    t1.setB( "hello" );

    Test2 t2;
    t2.setC( 234 );
}

bei Stackoverflow habe ich so ein Beispiel gefunden was denke ich in die 
richtige Richtung geht aber ich keine Ahnung wie ich meine Key-Inhalte 
zwischenspeichern kann

https://stackoverflow.com/questions/9831501/how-can-i-have-multiple-parameter-packs-in-a-variadic-template

template<typename... First>
struct Obj
{
    template<typename... Second>
    static void Func()
    {
        std::cout << sizeof...(First) << std::endl;
        std::cout << sizeof...(Second) << std::endl;
    }
};

[Niklas G. (erlkoenig)]

Man kann sich mit Tupeln behelfen. Der Umweg über das Lambda vermeidet 
die direkte Übergabe des ValueType-Parameters.

#include <string>
#include <tuple>

void eval_func( double target_, double value_ ){}
void eval_func( int target_, int value_ ){}
void eval_func( const std::string& target_, const char* value_ ){}

void store_func_A( int key1_, const std::string& key2_, double value_ ){}
void store_func_B( int key1_, const std::string& key2_, const std::string& value_ ){}
void store_func_C( double key1_, int value_ ){}

template <auto StoreFunc, typename ValueType, typename... Values, typename... Keys>
inline void OuterEvalAndStore(ValueType target_, std::tuple<Values...> values_, std::tuple<Keys...> keys_)
{
    // Diese Variante würde die explizite Übergabe von ValueType erfordern, wie unten auskommentiert gezeigt
//    std::apply (static_cast<void (*) (ValueType, Values...)> (eval_func)*/, std::tuple_cat (std::tuple<ValueType&> { target_ }, std::move (values_)));
    
    // Umweg über Lambda wählt automatisch den richtigen Overload
    std::apply ([&] (auto&&... values) { eval_func (target_, std::forward<decltype(values)> (values)...); }, std::move (values_));
    
    std::apply (StoreFunc, std::tuple_cat (std::move (keys_), std::tuple<ValueType&> { target_ }));
}

int main () {
  double t1;
  OuterEvalAndStore <store_func_A/* , double */> (t1, std::tuple { 3.14 }, std::tuple { 42, std::string { "foo" } });
  
  std::string t2;
  OuterEvalAndStore <store_func_B/*, const std::string& */> (t2, std::tuple { "42" }, std::tuple { 42 , std::string { "foo" } });
  
  int t3;
  OuterEvalAndStore <store_func_C/*, int*/> (t3, std::tuple { 42 }, std::tuple { 3.14 });
}

[cppbert3 (Gast)]

Direkt ins Schwarze beim 1. Versuch - danke Niklas

gcc.godbolt.org: https://gcc.godbolt.org/z/f37jr8

und so lange meine Keys keine Strings sind ist das inlining auch super

#include <tuple>
#include <string>

// "C-Artige"-Schnittstelle an die ich mich adaptieren will

void eval_func(double target_, double value_)
{
    int brk = 1;
}
void eval_func(int target_, int value_){}
void eval_func(const std::string& target_, const char* value_){}
void store_func_A(int key1_, const std::string& key2_, double value_){}
void store_func_B(int key1_, const std::string& key2_, const std::string& value_){}
void store_func_C(double key1_, int value_){}

template <auto StoreFunc, typename ValueType, typename... Values, typename... Keys>
inline void OuterEvalAndStore(ValueType target_, std::tuple<Values...> values_, std::tuple<Keys...> keys_)
{
    // Diese Variante würde die explizite Übergabe von ValueType erfordern, wie unten auskommentiert gezeigt
    //    std::apply (static_cast<void (*) (ValueType, Values...)> (eval_func)*/, std::tuple_cat (std::tuple<ValueType&> { target_ }, std::move (values_)));

    // Umweg über Lambda wählt automatisch den richtigen Overload
    std::apply([&](auto&&... values) { eval_func(target_, std::forward<decltype(values)>(values)...); },
        std::move(values_));

    std::apply(StoreFunc, std::tuple_cat(std::move(keys_), std::tuple<ValueType&>{ target_ }));
}

class Test1 {
private:
    template <auto StoreFunc, typename ValueType, typename... Values>
    inline void InnerEvalAndStore(ValueType& target_, Values&&... values_)
    {
        OuterEvalAndStore<StoreFunc>(target_, std::tuple{ std::forward<Values>(values_)... },
            std::tuple{ m_key1, m_key2 });
    }

public:
    void setA(double A_){ InnerEvalAndStore<store_func_A>(m_A, A_); }
    void setB(const char* B_){ InnerEvalAndStore<store_func_B>(m_B, B_); }
    //...

private:
    //keys (ueber ctor gesetzt)
    int m_key1{};
    std::string m_key2;

    //targets
    double m_A{};
    std::string m_B;
    //...
};

class Test2 {
private:
    template <auto StoreFunc, typename ValueType, typename... Values>
    inline void InnerEvalAndStore(ValueType& target_, Values&&... values_)
    {
        OuterEvalAndStore<StoreFunc>(target_, std::tuple{ std::forward<Values>(values_)... },
            std::tuple{ m_key1 });
    }

public:
    void setC(int C_){ InnerEvalAndStore<store_func_C>(m_C, C_); }
    //...

private:
    //keys (ueber ctor gesetzt)
    double m_key1{};

    //targets
    int m_C{};
    //...
};

int main()
{
    Test1 t1;
    t1.setA(23.0);
    t1.setB("hello");

    Test2 t2;
    t2.setC(234);

    return 0;
}

[cppbert3 (Gast)]

@Niklas

bald musst du dich entscheiden ob es ein Obstkorb mit Früchten der 
Südsee oder so ein Metzger-Körbchen mit grober Leberwurst und Speck 
werden soll :)

[Niklas G. (erlkoenig)]

cppbert3 schrieb:
> OuterEvalAndStore<StoreFunc>(target_, std::tuple{
> std::forward<Values>(values_)... },
>             std::tuple{ m_key1, m_key2 });

Versuch mal Referenzen in das Tupel zu speichern, dann vermeidet man das 
Kopieren der Keys, dürfte inlined auch kompakter werden:

OuterEvalAndStore<StoreFunc>(target_, std::tuple{ std::forward<Values>(values_)... }, std::tie (m_key1, m_key2));

cppbert3 schrieb:
> bald musst du dich entscheiden ob es ein Obstkorb mit Früchten der
> Südsee oder so ein Metzger-Körbchen mit grober Leberwurst und Speck
> werden soll :)

Haha, na andere sind hier ja auch sehr produktiv ;-)

[cppbert3 (Gast)]

Niklas G. schrieb:
> cppbert3 schrieb:
>> OuterEvalAndStore<StoreFunc>(target_, std::tuple{
>> std::forward<Values>(values_)... },
>>             std::tuple{ m_key1, m_key2 });
>
> Versuch mal Referenzen in das Tupel zu speichern, dann vermeidet man das
> Kopieren der Keys, dürfte inlined auch kompakter werden:
> OuterEvalAndStore<StoreFunc>(target_, std::tuple{
> std::forward<Values>(values_)... }, std::tie (m_key1, m_key2));

Ergibt Micro-Unterschiede - aber ich schreibe es mir mal dazu

> cppbert3 schrieb:
>> bald musst du dich entscheiden ob es ein Obstkorb mit Früchten der
>> Südsee oder so ein Metzger-Körbchen mit grober Leberwurst und Speck
>> werden soll :)
>
> Haha, na andere sind hier ja auch sehr produktiv ;-)

auf jeden Fall, jetzt gerade bist aber nur du hier - und hast mir auch 
schon echt oft schnell und gut geholfen, oder stalkst du meine Posts und 
ich muss mir sorgen machen? :)

[Niklas G. (erlkoenig)]

cppbert3 schrieb:
> Ergibt Micro-Unterschiede - aber ich schreibe es mir mal dazu

Gut, könnte sein dass der Compiler sonst nicht sieht dass das Kopieren 
des Strings unnötig ist und ihn eben unnötig kopiert.

cppbert3 schrieb:
> und hast mir auch
> schon echt oft schnell und gut geholfen, oder stalkst du meine Posts und
> ich muss mir sorgen machen? :)

Ne, ich klicke nur auf alles wo "C++" steht ;-) Die C++ Community auf 
Stack-Overflow ist auch sehr gut, und für schnelle Hilfe ist der 
Cpplang-Slack auch gut: https://cppalliance.org/slack/

PS: Mir fällt gerade auf dass ich einen Copy-Paste-Fehler gemacht habe, 
in der Parameter-Liste sollte "target_" eine Referenz sein:

template <auto StoreFunc, typename ValueType, typename... Values, typename... Keys>
inline void OuterEvalAndStore(const ValueType& target_, std::tuple<Values...> values_, std::tuple<Keys...> keys_)
{
    std::apply([&](auto&&... values) { eval_func(target_, std::forward<decltype(values)>(values)...); },
        std::move(values_));

    std::apply(StoreFunc, std::tuple_cat(std::move(keys_), std::tuple<const ValueType&>{ target_ }));
}

[cppbert3 (Gast)]

Niklas G. schrieb:
> cppbert3 schrieb:
>> Ergibt Micro-Unterschiede - aber ich schreibe es mir mal dazu
>
> Gut, könnte sein dass der Compiler sonst nicht sieht dass das Kopieren
> des Strings unnötig ist und ihn eben unnötig kopiert.

dann mache ich es jetzt rein

Niklas G. schrieb:
> PS: Mir fällt gerade auf dass ich einen Copy-Paste-Fehler gemacht habe,
> in der Parameter-Liste sollte "target_" eine Referenz sein:

Mensch, Niklas!!!

[cppbert3 (Gast)]

in meiner echten Implementierung habe ich jetzt mehrere (3) 
Funktion-Templates welche die ...Keys, ...Values und noch ein paar 
andere Objekte brauchen

die ...Keys und anderen Objekte brauchen alle

könnte man die irgendwie in eine Template-Klasse stecken welche ich dann 
lokal privat Instanziere damit ich die Keys immer da habe

also in der Art

template<typename... Keys>
class Helper
{
  Helper(obj1, obj2, std::tuple<Keys...> keys_):m_keys(keys_){}

  template <auto StoreFunc, typename ValueType, typename... Values>
  inline void EvalAndStore(const ValueType& target_, std::tuple<Values...> values_)
{
    std::apply([&](auto&&... values) { eval_func(target_, std::forward<decltype(values)>(values)...); },
        std::move(values_));

    std::apply(StoreFunc, std::tuple_cat(std::move(m_keys), std::tuple<const ValueType&>{ target_ }));
}

private:
  std::tuple<Keys...> m_keys;
};

class Test
{
public:
  Test():
    m_helper(objX, objY, m_key1, m_key2)
  {
  }
private:// internals
  Helper m_helper;

public:
  
};

und wenn das geht wie kann man verhindern das diese lokale Hilfsobjekt 
die Keys usw. kopiert

Eine Idee?

[cppbert3 (Gast)]

in public fehlte noch

public:
    void setC(int C_){ m_helper.EvalAndStore<store_func_C>(m_C, C_); }
    //...

[Niklas G. (erlkoenig)]

Sieht doch schon gut aus. Durch den strategischen Einsatz von std::move 
im Konstruktur, und Overloads für verschiedene Referenz-Typen des 
"keys_"-Arguments kann man Kopien vermeiden, ohne die Typsicherheit zu 
verlieren:

class Helper {
  Helper (obj1, obj2, std::tuple<Keys...>&& keys_) : m_keys (std::move (keys_)) {}
  Helper (obj1, obj2, const std::tuple<Keys...>& keys_) : m_keys (keys_) {}

Oder nur den 1. gezeigten Overload behalten, falls man sowieso nie 
"const&" braucht.

[cppbert3 (Gast)]

Niklas G. schrieb:
> Sieht doch schon gut aus. Durch den strategischen Einsatz von
> std::move
> im Konstruktur, und Overloads für verschiedene Referenz-Typen des
> "keys_"-Arguments kann man Kopien vermeiden, ohne die Typsicherheit zu
> verlieren:
> class Helper {
>   Helper (obj1, obj2, std::tuple<Keys...>&& keys_) : m_keys (std::move
> (keys_)) {}
>   Helper (obj1, obj2, const std::tuple<Keys...>& keys_) : m_keys (keys_)
> {}
> Oder nur den 1. gezeigten Overload behalten, falls man sowieso nie
> "const&" braucht.

meine Keys sind unveränderlich also eigentlich immer (const) members - 
die duerfen sich nie aendern

[cppbert3 (Gast)]

das ist mein Ergebnis

template <typename Store, typename... Keys>
class ModifierHelper
{
public:
    ModifierHelper( Store& history_, const std::tuple<Keys...>& keys_ )
        : m_store( store_ ),
          m_keys( keys_ )
    {
    }

    template <auto StoreFunc, typename ValueType>
    inline void EvalAndStore( ValueType value_, ValueType& target_ )
    {
        if( target_ == value_ )
        {
            return;
        }
        target_ = value_;
        std::apply( StoreFunc, std::tuple_cat( std::make_tuple( m_store ), std::move( m_keys ),
                                                std::tuple<ValueType&>{ value_ } ) );
    }

private:
    Store& m_store;
    std::tuple<Keys...> m_keys;
};

[Niklas G. (erlkoenig)]

So wird aber immer kopiert... Wär's nicht sinnvoller, aus "m_keys" eine 
Referenz zu machen? Sind die Keys ein Member der äußeren Klasse (oben: 
"Test")? Dann hast du eine gewisse Duplikation.

[cppbert3 (Gast)]

Niklas G. schrieb:
> So wird aber immer kopiert... Wär's nicht sinnvoller, aus "m_keys"
> eine
> Referenz zu machen? Sind die Keys ein Member der äußeren Klasse (oben:
> "Test")? Dann hast du eine gewisse Duplikation.

ja das sind die Keys der äußeren Klasse von der es eben X Varianten gibt
die Keys sind eigentlich sogar const (mache ich jetzt) weil die niemals 
veraendert werden duerfen

wie wäre es denn ideal wenn die m_key?s immer const wären und problemlos 
per const& uebergeben werden können

bisher erzeuge ich so mein HelperObject

private: // internal
    ModifierHelper<Store, decltype( m_key1 ), decltype( m_key2 )> 
m_helper;

und im ctor dann so
   , m_helper( m_store, { m_key1, m_key2 } )

[cppbert3 (Gast)]

habs mals const&-ed

private:
    //keys (ueber ctor gesetzt)
    const double m_key1{};
    const int m_key2{};
private: // internal
    const ModifierHelper<Store, decltype( m_key1 )&, decltype( m_key2 )&> 
m_helper;

und im ctor dann so

   , m_helper( m_store, { m_key1, m_key2 } )

[Niklas G. (erlkoenig)]

Das heißt aber dass ModifierHelper nur Referenzen in das enthaltende 
Objekt enthält. Daher ist es eher sinnlos permanent eine Instanz davon 
zu haben. Wäre es nicht sinnvoller eine inline-Funktion zu definieren, 
welche ein temporäres ModifierHelper-Objekt erzeugt und zurückgibt, mit 
dem man dann jeweils arbeitet? Durch das inlining wird das Erstellen des 
Objekts wegoptimiert.

[cppbert3 (Gast)]

Niklas G. schrieb:
> Das heißt aber dass ModifierHelper nur Referenzen in das
> enthaltende
> Objekt enthält. Daher ist es eher sinnlos permanent eine Instanz davon
> zu haben. Wäre es nicht sinnvoller eine inline-Funktion zu definieren,
> welche ein temporäres ModifierHelper-Objekt erzeugt und zurückgibt, mit
> dem man dann jeweils arbeitet? Durch das inlining wird das Erstellen des
> Objekts wegoptimiert.

das hört sich auch gut an

d.h. ich ersetze meinen m_helper+ctor init

durch so eine Member-Funktion?

auto& helper() const
{
  return ModifierHelper<Store>(m_store,  m_key1, m_key2);
}

und dann rufe ich die in allen meinen settern/gettern auf

public:
    void setC(int C_){ helper().EvalAndStore<store_func_C>(m_C, C_); }

oder?

[Niklas G. (erlkoenig)]

Ja ganz genau. Am Besten die "helper()" -Funktion noch mit "inline" 
markieren.

[cppbert3 (Gast)]

muss als Kopie zurueckliefern sonst ists ein wenig kaputt