C++, Einen Methoden-Dispatcher zur Kompilezeit erzeugen?

[CppBert (Gast)]

Sorry für den Haufen Quelltext - aber ich wollte ein Beispiel machen das 
auch getestet werden kann - weniger ist sehr schwierig, ohne tausend 
Fragen offen zu lassen.

Und Nein, es ist keine Hausaufgabe :)

zum Online kompilieren/ausführen: https://onlinegdb.com/SyMiIheEN

#include <cassert>
#include <tuple>
#include <vector>

// Ich brauche ein Template (oder Tips) wie ich von einer Dispatcher-Klasse aus
// ohne viel Boilerplate-Code native Methoden aufrufen kann
// Das ganze Konzept funktioniert (schon etwas länger) wie es soll 
// aber ich würde sehr gerne den Boilerplate Code reduzieren 

// Hier ein stark vereinfachtes Beispiel - es geht mir in keinster Weise
// um das Grundkonzept (das erkennt man in diesem Beispiel nicht wirklich) 
// sonder nur um ein bisschen Template-Magic in der
// itest_class::test2_waere_perfekt Methode - der Rest-Code
// ist nur damit meine Frage nicht total abstrakt ist
// und man auch was ausführen kann

// mit up-to-date: VS2017 15.9.6 oder gcc 8.2, also (fast) alles was C++17 so hergibt

struct i_value // Value-Schnittstelle fuer Konstanten,Expression,Referenzen,...
{
  // INFO: Mein Framework stellt per Reflection-Prinzip magisch sicher das nur die selben Typen verbunden werden (void* ist bei mir 100% safe)
  virtual void set(const void* const value) = 0;
  virtual void get(void* const value) = 0;
};

// hier in diesem Beispiel reduziere ich das ganze auf "Variablen"
// also Objekte die das i_value Interface implementierung und einen Value-Zustand haben
template<typename ValueType>
struct value_t : i_value
{
  ValueType _value = ValueType();
  value_t(const ValueType& value) :_value(value) {}

  // hier ist normalerweise noch Absicherungs-Code drinn/dahinter/drumherum
  const ValueType& magical_safe_cast(const void* const value) const
  {
    return *reinterpret_cast<const ValueType*>(value);
  }
  ValueType& magical_safe_cast(void* value)
  {
    return const_cast<ValueType&>(static_cast<const value_t*>(this)->magical_safe_cast(value));
  }

  void set(const void* const value) override
  {
    set(magical_safe_cast(value));
  }

  void get(void* value) override
  {
    magical_safe_cast(value) = get();
  }

  void set(const ValueType& value)
  {
    _value = value;
  }

  ValueType& get()
  {
    return _value;
  }
};

// liefert den return-type einer Methode
template <typename Return, typename Class, typename ... Parameter>
Return get_return_type(Return(Class::*)(Parameter...));

// liefert die parameter-typen einer Methode
template <typename Class, typename Return, typename... Parameter>
std::tuple<Parameter...> method_args(Return(Class::*)(Parameter...))
{
  return std::tuple<Parameter...>();
}

// kleine Abstraktion um in, out und inout Verhalten zu erzeugen
template<typename ValueType>
struct in_parameter_t
{
  ValueType _native_value = ValueType();
  i_value* _value = nullptr;
  in_parameter_t(i_value* value) :_value(value) {}

  void load()
  {
    _value->get(&_native_value);
  }

  void store() {} // nicht implementiert da IN

  ValueType& operator()()
  {
    return _native_value;
  }
};

template<typename ValueType>
struct out_parameter_t
{
  ValueType _native_value = ValueType();
  i_value* _value = nullptr;
  out_parameter_t(i_value* value) :_value(value) {}

  void load() {} // nicht implementiert da OUT

  void store()
  {
    _value->set(&_native_value);
  }

  ValueType& operator()()
  {
    return _native_value;
  }
};

template<typename ValueType>
struct inout_parameter_t
{
  ValueType _native_value = ValueType();
  i_value* _value = nullptr;
  inout_parameter_t(i_value* value) :_value(value) {}

  void load()
  {
    _value->get(&_native_value);
  }

  void store()
  {
    _value->set(&_native_value);
  }

  ValueType& operator()()
  {
    return _native_value;
  }
};

// traits um aus den Methoden/Result-Typen den richtigen Adapter zu bekommen

template<typename ValueType>
struct parameter_type_t {};

template<>
struct parameter_type_t<const int&>
{
  using type = in_parameter_t<int>;
};

template<>
struct parameter_type_t<const int>
{
  using type = in_parameter_t<int>;
};

template<>
struct parameter_type_t<const double&>
{
  using type = in_parameter_t<double>;
};

template<>
struct parameter_type_t<const double>
{
  using type = in_parameter_t<double>;
};

template<>
struct parameter_type_t<int&>
{
  using type = inout_parameter_t<int>;
};

template<>
struct parameter_type_t<double&>
{
  using type = inout_parameter_t<double>;
};

// "native" classe von der ich Methoden per ueber die itest_class aufrufen will
struct test_class
{
  int value = 100;

  void test0() { return; }
  void test1(const int& x, const double& y) { return; }
  double test2(const int& x, const double& y, double& z)
  {
    double res = x + y;
    z = 10;
    return res;
  }
  int& test3() { return value; }
};

using iparameter = std::vector<i_value*>;

// "native" class Wrapper/Dispatcher
// mein Framework erlaubt magisch-dynamisch das Aufrufen dieser Dispatch-Funktionen (mit ivalue Parametern)

struct itest_class
{
  test_class object; // liegt normalerweise wo anders

  // Stufe 0: alles von Hand, maximal unsicher (auch wenn ich mit Tricks hier Fehler erkenne)
  void test2_von_hand(const iparameter& parameter, i_value* const result)
  {
    assert(parameter.size() == 3);

    int x = 0;
    double y = 0.0;
    double z = 0.0;
    double res = 0.0;

    // load
    parameter[0]->get(&x); // IN
    parameter[1]->get(&y); // IN
    parameter[2]->get(&z); // INOUT

    // run
    res = object.test2(x, y, z);

    // store
    result->set(&res);
    //parameter[0]->set(&x); // nicht noetig da IN parameter
    //parameter[1]->set(&y); // nicht noetig da IN parameter
    parameter[2]->set(&z);
  }

  // hier habe ich versucht micht reflektiv an der nativen-Methode zu orientieren
  // weniger Fehler, aber zu viel Code - nur eine Blaupause fuer die wohl notwendigen
  // Template-Helper
  void test2_bisschen_besser(const iparameter& parameter, i_value* const result)
  {
    // die Methoden-Signatur abgreifen
    using native_parameter_types = decltype(method_args(&test_class::test2));
    using native_return_type = decltype(get_return_type(&test_class::test2));
    static_assert(!std::is_same<native_return_type, void>::value, "void fehlt noch");

    assert(parameter.size() == std::tuple_size<native_parameter_types>::value);

    // diesen tuple muesste man doch zur kompilezeit generieren koennen, oder?
    using parameter_types_t = std::tuple
      <
      parameter_type_t<std::tuple_element<0, native_parameter_types>::type>::type,
      parameter_type_t<std::tuple_element<1, native_parameter_types>::type>::type,
      parameter_type_t<std::tuple_element<2, native_parameter_types>::type>::type
      >;

    // diese instanzen vielleicht in einem tupel halten - aber wie geht das?
    std::tuple_element<0, parameter_types_t>::type p0(parameter[0]);
    std::tuple_element<1, parameter_types_t>::type p1(parameter[1]);
    std::tuple_element<2, parameter_types_t>::type p2(parameter[2]);

    using res_t = out_parameter_t<native_return_type>;
    res_t res(result);

    // load - schoen homogen, kann man das zur kompilezeit expandieren?
    p0.load();
    p1.load();
    p2.load();

    // run
    // https://cpppatterns.com/patterns/apply-tuple-to-function.html // laut diesem tutorial kann man methoden auch mit tupels aufrufen
    res() = object.test2(p0(), p1(), p2());
    // wie koennte man native_return_type == void loesen? if constexpr?

    // store
    res.store(); // setzt was

    // schoen homogen, kann man das zur kompilezeit expandieren?
    p0.store(); // macht nichts
    p1.store(); // macht nichts
    p2.store(); // setzt was
  }

  void test2_waere_perfekt(const iparameter& parameter, i_value* const result)
  {
    //!!!
    //Ziel meine Frage: Wie kann ich so ein run_method Template implementieren um
    //mir den ganzen Boilerplate Code zu sparen

    // mein Gefühl sagt mir das so ein Template moeglich sein muesste
    //run_method(&object, &test_class::test2, parameter, result);
  }
};


int main()
{
  // Dispatcher-Klasse instanzieren
  itest_class itest_object;

  value_t<int> x(11); // value by ref
  value_t<double> y(22.0); // value by ref
  value_t<double> z(44.0); // ref
  iparameter parameter{ &x, &y, &z };

  value_t<double> result(0);

  result.set(0.0);
  z.set(0.0);
  itest_object.test2_von_hand(parameter, &result);
  assert(result.get() == 33.0);
  assert(z.get() == 10.0);

  result.set(0.0);
  z.set(0.0);
  itest_object.test2_bisschen_besser(parameter, &result);
  assert(result.get() == 33.0);
  assert(z.get() == 10.0);

  //result.set(0.0);
  //z.set(0.0);
  //itest_object.test2_waere_perfekt(parameter, &result);
  //assert(result.get() == 33.0);
  //assert(z.get() == 10.0);

  return 0;
}

[900ss (900ss)]

Und weshalb hängst du deinen Sourcecode nicht einfach als Datei an dein 
Posting? Das kann man auch sehr leserlich sogar mit Syntax Highlight 
hier ansehen. Und dein Posting wäre nicht kilometer lang.

[CppBert (Gast)]

Als Anhang - ging nicht im Chrome, aber im Firefox klappt es?

[CppBert (Gast)]

Noch ein bisschen weiter probiert

jetzt versuche ich

  void test2_bisschen_besser(const iparameter& parameter, i_value* const result)
  {
    // die Methoden-Signatur abgreifen
    using native_parameter_types = decltype(method_args(&test_class::test2));
    using native_return_type = decltype(get_return_type(&test_class::test2));
    static_assert(!std::is_same<native_return_type, void>::value, "void fehlt noch");

    assert(parameter.size() == std::tuple_size<native_parameter_types>::value);

    // diesen tuple muesste man doch zur kompilezeit generieren koennen, oder?
    using parameter_types_t = std::tuple
      <
      parameter_type_t<std::tuple_element<0, native_parameter_types>::type>::type,
      parameter_type_t<std::tuple_element<1, native_parameter_types>::type>::type,
      parameter_type_t<std::tuple_element<2, native_parameter_types>::type>::type
      >;

    auto p = parameter_types_t
    (
      parameter[0], 
      parameter[1], 
      parameter[2]
    );

    // load - schoen homogen, kann man das zur kompilezeit expandieren?
    std::get<0>(p).load();
    std::get<1>(p).load();
    std::get<2>(p).load();

    using res_t = out_parameter_t<native_return_type>;
    res_t res(result);

    // https://cpppatterns.com/patterns/apply-tuple-to-function.html // laut diesem tutorial kann man methoden auch mit tupels aufrufen
    res() = object.test2(
      std::get<0>(p)(),
      std::get<1>(p)(),
      std::get<2>(p)()
    );

    // store
    res.store(); // setzt was

    // schoen homogen, kann man das zur kompilezeit expandieren?
    std::get<0>(p).store(); // macht nichts
    std::get<1>(p).store(); // macht nichts
    std::get<2>(p).store(); // setzt was
  }

[M.K. B. (mkbit)]

Dunkle Templatemagie, juhu. :-D
Ich hab allerdings irgendwie die Vermutung, dass du mit Templates C++ 
Variablen nachbaust. Vielleicht kannst du mir erklären, wofür man das 
ganze verwenden kann. ich würde gerne verstehen, was du damit optimieren 
möchtest.

Ich konnte das folgende nicht ausprobieren, aber vielleicht hilft das. 
Du kannst ja deinen Fortschritt posten, fände ich auf jeden Fall 
interessant.

// diesen tuple muesste man doch zur kompilezeit generieren koennen, 
oder?
Das müsste mit Variadic Templates gehen. 
https://stackoverflow.com/questions/17618938/how-to-make-a-tuple-from-a-tuple/17619059?noredirect=1#17619059

// diese instanzen vielleicht in einem tupel halten - aber wie geht das?
Warum machst du das load nicht beim Funktionsaufruf, dann brauchst du 
das Tuple nicht.

// load - schoen homogen, kann man das zur kompilezeit expandieren?
Vielleicht über rekursive Templates, aber hier würde ich auf 
Loopunrolling des Compilers setzen und das mit einer Schleife machen.

[CppBert (Gast)]

>Dunkle Templatemagie, juhu. :-D

gar nicht soo dunkel

>Ich hab allerdings irgendwie die Vermutung, dass du mit Templates C++
>Variablen nachbaust. Vielleicht kannst du mir erklären, wofür man das
>ganze verwenden kann. ich würde gerne verstehen, was du damit optimieren
>möchtest.

Kurz: Ich habe ein Framework welches erlaubt in einem UI - Objekte(mit 
Methoden), Expressions, usw. zu erzeugen
und diese mit einandern zu verschränken - so eine Art Programmiersystem

Konzept: du schreibst eine normale Klasse mit Members und Methoden und 
schreibst
dazu eine Klasse welche die Fähigkeiten der normalen Klasse so 
beschreibt das
du sie frei wählen, instanziern und Methoden aufrufen kannst - das geht 
alles

aber der Code um von der Abstrakten Schnittstelle in die echte 
Implementierung
zu kommen ist einfach ein wenig umfangreich

aber mit Templates laesst sich das definitiv in einen Einzeiler 
verwandeln - ich
bin nur einfach nicht so fit mit den C++11,14,17 Variadic 
Templates/Folding expressions usw
und tu mich da schwer

mein jetztiges Beispiel enthält in der test2_von_hand-Methode den 
jetzigen Code
für so einen Abstrakte-Schnittstelle->native-Schnittstelle adaption

die test2_bisschen_besser-Methode extrahiert z.B. schon direkt aus der 
nativen Methode
den Return-Type und die Parameter - jetzt fehlt nur noch etwas code der 
die
homogenen Teile zur Kompilezeit expandiert - schwupps muss ich gar 
keinen Adaptions-Code
mehr schreiben

[tictactoe (Gast)]

Ich bin mir nicht sicher, ob das möglich ist. Die Anzahl der Parameter 
ist dynamisch (parameter.size()), die kannst du mit variadic Templates 
überhaupt nicht aufschließen, weil da die Anzahl ja zur Compile-Zeit 
bekannt sein muss. Aber die Parametertypen sind statisch 
(iparameter::value_type ist ein Pointer auf die Basisklasse), das stellt 
den Zweck von Templates in Frage.

Natürlich könnte ich aber mit meinem Verständnis vom Problem komplett 
auf dem Holzweg sein...

[Bert3 (Gast)]

tictactoe schrieb:
> Ich bin mir nicht sicher, ob das möglich ist. Die Anzahl der Parameter
> ist dynamisch (parameter.size()), die kannst du mit variadic Templates
> überhaupt nicht aufschließen, weil da die Anzahl ja zur Compile-Zeit
> bekannt sein muss

Die orientierung ist die signatur der methode, die ist komplett zur 
kompilezeit verarbeitbar, der parameter vektor wird nur ein runtime 
parameter sein, nicht alles muss zur kompilezeit evaluiert werden 
koennen damit ich templates nutzen kann

[CppBert (Gast)]

Ich habe das Beispiel und die Fragen noch mal drastisch gekürzt - so wie 
ich es auch im CppForum gepostet habe

Online Kompilieren/Ausführen: https://onlinegdb.com/Skk-I3WNN

// aktuelle VS2017 Version, oder GCC 8.2, C++14 oder C++17 waere moeglich

#include <tuple>
#include <vector>
#include <cassert>

template<typename Value>
struct in_parameter_t
{
    in_parameter_t(void* value) {}
};

template<typename Value>
struct inout_parameter_t
{
    inout_parameter_t(void* value) {}
};

template<typename ValueType>
struct parameter_type_t {};

template<>
struct parameter_type_t<int>
{
    using type = in_parameter_t<int>;
};

template<>
struct parameter_type_t<int&>
{
    using type = inout_parameter_t<int>;
};

using parameter_t = std::vector<void*>;

int main()
{
    //------
    // Kompilezeit-Parameter
    // Methoden-Parameter-Typen
    using native_parameter_types = std::tuple<int,int&>;
    //------
    // Laufzeit-Parameter
    int p0 = 0;
    int p1 = 0;
    parameter_t parameter{&p0, &p1}; // muss ein std::vector sein (std::array ist zu fix)
    // zur Laufzeit garantiert das zu jedem native_parameter_types[x] ein parameter[x] existiert
    assert(parameter.size() == std::tuple_size<native_parameter_types>::value);
    //------
    
    // hier kommen mein Fragen

    // aus dem nativen typ einen adapter typ erzeugen
    using parameter_types_t = std::tuple
                              <
                              parameter_type_t<std::tuple_element<0, native_parameter_types>::type>::type,
                              parameter_type_t<std::tuple_element<1, native_parameter_types>::type>::type
                              >;
    //====> FRAGE 1: geht das auch mit einer Template-Funktion?
    //so in der Art?
    //using parameter_types_t = get_parameter_types<native_parameter_types>::types;

    // die adapter mit dem parameter-pointer instanzieren
    auto p = parameter_types_t
             (
                 parameter[0],
                 parameter[1]
             );
    //====> FRAGE 2: geht das auch mit einer Template-Funktion?
    //so in der Art?
    //auto p = get_parameter<parameter_types_t>(parameter);

    return 0;
}

[tictactoe (Gast)]

Ok, verstanden. Ja, das müsste mit variadic Templates gehen, und zwar 
mit std::index_sequence.

Da wird eine Hilfsfunktion benötigt, die einen Parameter 
std::index_sequence<I...> hat. Das Argument dazu ist 
std::index_sequence_for<sizeof...T> (wenn T ein Parameter-Pack ist) oder 
in deinem Fall wohl eher 
make_index_sequence<tuple_size<parameter_types_t>::value>{}.

In der Hilfs-Templatefunktion kann man dann z.B mit parameter[I]... auf 
einzelnen Werte im vector zugreifen. Oder den Hilfstyp konstruieren:

using parameter_types_t = std::tuple<parameter_type_t<std::tuple_element<I, native_parameter_types>::type>::type...>

Ich hab' das zuletzt hier gemacht:

https://github.com/j6t/cpptk/blob/0809f20ba028a87c58587c4024c5c8a910d2adcf/base/cpptkbase.h#L298-L310

aber nicht verwirren lassen: im dortigen Beispiel ist die get-Funktion 
nicht std::get, sondern eine Member-Template der Klasse Params.

[CppBert (Gast)]

@tictactoe - so in etwa?

namespace detail
{
  template <typename ParameterTypesTuple_TP, size_t... Indice_TP>
  auto get_parameter(parameter_t& parameter,   std::index_sequence<Indice_TP...>)
  {
    return ParameterTypesTuple_TP(parameter[Indice_TP]...);
  }
}

template <typename ParameterTypesTuple_TP>
auto get_parameter(parameter_t& parameter)
{
  constexpr auto size = std::tuple_size<ParameterTypesTuple_TP>::value;
  return detail::get_parameter<ParameterTypesTuple_TP>(parameter, std::make_index_sequence<size>());
}

macht aus

auto p = parameter_types_t
(
  parameter[0],
  parameter[1]
);

diesen code

auto p = get_parameter<parameter_types_t>(parameter);

und es scheint auch zu funktionieren :) - super

aber das pure mapping von einem typ-tuple auf einen anderen macht mir 
noch probleme - ich weiss nicht wo ich die index_sequence 
hinstellen/initalisieren soll wenn ich doch nur einen Typ erzeuge (also 
keine helper-funktion sondern ein struct mit using types = xyz habe)

kannst du mir dafür noch ein kleines Beispiel "konkretisieren"

  using parameter_types_t = std::tuple
    <
    parameter_type_t<std::tuple_element<0, native_parameter_types>::type>::type,
    parameter_type_t<std::tuple_element<1, native_parameter_types>::type>::type
    >;

[CppBert (Gast)]

irgendwie so denke ich

template<typename NativeParameterTypesTuple_TP>
struct get_parameter_types
{
  constexpr auto size = std::tuple_size<NativeParameterTypesTuple_TP>::value;
  //std::get<N>(std::forward<NativeParameterTypesTuple_TP>(t))...
  //using types = ...
};

ich komme einfach nicht drauf wo ich meine index_sequence einbauen muss

using parameter_types_t = std::tuple
<
  parameter_type_t<std::tuple_element<0, native_parameter_types>::type>::type,
  parameter_type_t<std::tuple_element<1, native_parameter_types>::type>::type
>;

[tictactoe (Gast)]

Du baust dir eine Template-Funktion, die den gewünschten Typ 
zusammenbaut und als Rückgabewert hat, ähnlich wie get_parameter(); 
nennen wir sie get_parameter_types(). Dann brauchst du nur mehr sagen:

using parameter_types_t = decltype(get_parameter_types(native_parameter_types));

Normalerweise macht man solche Typtransformationen ja über 
Klassentemplates, aber hier brauchen wir irgendwo auf dem Weg 
Funktionen, damit der Compiler den Parameter-Typ 
std::index_sequence<Indice_TP...> ableitet.

[M.K. B. (mkbit)]

Das war mal wieder eine nette Aufgabe um wieder etwas Meta Template 
Programming zu üben. :-)

Im Anhang hab ich meine Version mit Lösung der Probleme angehängt. Am 
besten mit dem Original vergleichen und dann Fragen, wenn was unklar 
ist. Ich habe auch Dinge geändert, die kein Problem der Fragestellung 
waren, aber vielleicht ganz lehrreich sein könnten. Im Code sind auch 
Links zu Foren, die mich auf die Ideen gebracht habe. Wenn einer noch 
eine bessere Lösung hat, ich lerne gerne dazu.

Hier ein paar Anmerkungen zu meine Änderungen:
Seit C++14 kann man type und value kürzer schreiben.

std::tuple_element<0, native_parameter_types>::type
std::tuple_element_t<0, native_parameter_types>

std::is_same<native_return_type, void>::value
std::is_same_v<native_return_type, void>

Den parameter_type_t habe ich mal über enable if für arithmetische Typen 
automatisch spezialisieren lassen. Dann muss man das nicht für jeden 
Integertyp explizit machen.

Der Trick bei der Typeumwandlung ist, dass man nicht das Tuple als 
Templateparameter angibt. Damit werden die Typen im Tuple als Args 
genommen. Diese Parameter entpackt man und erstellt daraus ein neues 
Tuple.

template <typename... Args>
struct convert_to_param_type_t<std::tuple<Args...>>
{
     using type = std::tuple<typename parameter_type_t<Args>::type...>;
};

Das ausführen einer Funktion auf jedem Element des Tuples und das Laden 
aus dem Vektor funktioniert über eine Zwischenebene, die die Indizes für 
den Tuplezugriff erzeugt. In meinem Fall ist die Funktion explizit 
angegeben. Ich fände es interessant, ob man die Funktion auch von außen 
(z.B. als Lambda) mitgeben kann. Bei mir scheiterte es aber immer daran, 
dass diese ja für verschiedene Typen gültig sein muss.

template <typename... Args>
static void load_each(std::tuple<Args...>& t)
{
     // Tuple weiterleiten
     // Aus der Anzahl der Tupleelemente Compiletimeindizes erzeugen.
     // Man erzeugt hier eine Instanz einer integer_sequence, aber die Indizes sind im Typ und nicht als Member enthalten, also erzeugt dies keinen Code.
     load_each(t, std::index_sequence_for<Args...>{});
}

template <typename... Args, std::size_t... Idx>
static void load_each(std::tuple<Args...>& t, std::index_sequence<Idx...>)
{
    // Diese fold expression expandiert die Indizes, wichtig sind die äußeren Klammern.
    (std::get<Idx>(t).load(), ...);
    // Der Compiler macht daraus 
    // (std::get<0>(t).load(), std::get<1>(t).load(), std::get<2>(t).load())
}

[CppBert (Gast)]

und wie expandiere ich meinen native_parameter_types-tuple damit ich mit 
den parameter-packs arbeiten kann?

Ich häng total

[CppBert (Gast)]

irgendwie so?

namespace detail
{
  template <typename NativeTypesTuple_TP, size_t... Indice_TP>
  auto get_parameter_types(std::index_sequence<Indice_TP...>)
  {
    return std::tuple< typename parameter_type_t<typename std::tuple_element<Indice_TP, NativeTypesTuple_TP>::type >::type... >();
  }
}

template <typename NativeTypesTuple_TP>
using get_parameter_types = decltype(detail::get_parameter_types<NativeTypesTuple_TP>(std::make_index_sequence<std::tuple_size<NativeTypesTuple_TP>::value>()));

mein Problem ist das ich den nicht einfach default-Konstruiert 
zurueckliefern kann - meine tuple-elemente können nicht 
default-konstruiert werden
fällt dann die Lösung mit der template-Funktion weg?

[M.K. B. (mkbit)]

CppBert schrieb:
> und wie expandiere ich meinen native_parameter_types-tuple damit ich mit
> den parameter-packs arbeiten kann?

Mein Code ist übrigens in VS 2017 compilierbar (andere nicht getestet) 
und funktioniert.

Ich geh mal davon aus, dass du die Typen expandieren willst. Das 
funktioniert anders, als wenn man mit den Werten arbeiten will.
Das Problem hatte ich erst auch, aber das macht man mit folgendem Trick. 
Ich zeigs mal an einem einfachen Beispiel.

template <typename... Args>
struct convert_to_param_type_t;

// Templatespezialiserung für tuple Typen.
// !!! Kein Tuple im Templateparameter Args
template <typename... Args>
struct convert_to_param_type_t<std::tuple<Args...>>
{
    using type = std::tuple<typename parameter_type_t<Args>::type...>;
};

using native_parameter_types = std::tuple<int, double>;

// Hier wird konvertiert:
using parameter_types_t = convert_to_param_type_t<native_parameter_types>::type;

Der Compiler will jetzt das Template convert_to_param_type_t 
instanzieren. Der übergeben Type ist eine Tuple, deswegen greift hier 
die Spezialisierung. Aus dem Tupletype werden die variadic 
Templateparameter deduced (Args = int, double).
Die Args werden entpackt und daraus ein neuer Type erzeugt.

// Das macht der Compiler.
using type = std::tuple<parameter_type_t<int>::type, parameter_type_t<double>::type>>;

[CppBert (Gast)]

@M.K. B.
ja das funktioniert wie es soll :)

@tictactoe
Danke auch für deine Mühen - ohne decltype fühlt sich an dieser Stelle 
richtiger an

hab ihr noch eine Idee wie ich folgendes loesen könnte

template <size_t Index>
struct info_t{};

template <>
struct info_t<0>
{
  static constexpr auto name = "Erster";
};
  
template <>
struct info_t<1>
{
  static constexpr auto name = "Zweiter";
};

using infos = std::tuple
<
  info_t<0>,
  info_tr_t<1>
  //...
  //info_t<N>
>;

//hier braeuchte ich eine template welches alle infos von 0..N
// in den tuple steckt
template<size_t LastInfo>
using collect_infos = ... ???

using infos = collect_infos<2>;

eine Idee?

ansonsten ich meine Anfangs-Frage schon zu 100% beantwortet - alles 
funktioniert wie es soll

[CppBert (Gast)]

noch als info wiso ich bei der collect_infos<N> sache nicht weiter 
komme:

ja ich denke ich brauche eine integer_sequence d.h. für mich das ich 
irgendeinen form von template-funktion brauche (eben für die sequence), 
aber am ende soll wieder nur ein Typ dabei rauskommen (kein value) also 
kein return sonder ein unsing infos_t = xyz ...

ich bin mir nie sicher wann ich mit sequencen, return und decltype 
arbeiten soll und wann ich gezwungen bin es völlig anders zu machen

[CppBert (Gast)]

Habe es hin bekommen - ABER...

namespace detail {

template<size_t ... I>
auto collect_infos(std::index_sequence<I ...>)
{
  using infos= std::tuple<info_t<I>...>;
  return infos();
}

}

template<size_t Count>
using collect_infos = 
decltype(detail::collect_infos(std::make_index_sequence<Count>{}));

Fragen:
-wie kann ich die info_t durch einen template-Parameter ersetzen?

wenn ich anstatt info_t ein Info-Template parameter = info_t nutze 
kompilierts nicht wegen unvollstaendigem typ

-was würde ich machen wenn meine Tuple-Types sind default-Konstruierbar 
ist? also der decltype-Trick nicht funktioniert?

[M.K. B. (mkbit)]

CppBert schrieb:
> ich bin mir nie sicher wann ich mit sequencen, return und decltype
> arbeiten soll und wann ich gezwungen bin es völlig anders zu machen

Mein Eindruck war bisher immer, dass man eine Sammlung von "Tricks" 
braucht und dann etwas Kreativität.

Wann benutzt man return?
Wann man Daten zurückgeben möchte.

Wann benutzt man using?
Wenn man Typdaten "zurückgeben" möchte.

Wann benutzt man decltype?
Wenn man den Typ eines Ausdrucks ermitteln möchte. Das kann hilfreich 
sein, wenn man z.B. überladene Funktionen mit verschiedenen 
Rückgabetypen hat. Jetzt könnten man sich dafür eine Template 
Lookuptabelle mit den Typen machen. Alternativ nutzt man decltype auf 
dem Funktionsaufruf. Je nach Fall kann das einfacher sein.

Wann benutzt man sequence?
Wenn man den Index braucht und nicht einfach nur eine Liste. In deinem 
Projekt brauchst du es einmal um im Vektor die richtigen Elemente zu 
lesen oder um die Info aus einer Indexbasierten Tabelle auszulesen. Für 
die Typkonvertierung braucht man es nicht, weil man es einfach nur auf 
jedem Element anmelden möchte und der Index nicht nötig ist.

Sonst braucht man außerdem häufig zwei Ebenen, weil man mit dem ersten 
Template irgendwas aus dem Typ ermittelt und das dann an die zweite 
Ebene weitergibt. Wie z.B. bei dem Tuple, wo man mit dem ersten Template 
die Typen in ein parameter pack umwandelt und das mit dem anderen 
Template konvertiert.

[M.K. B. (mkbit)]

CppBert schrieb:
> Fragen:
> -wie kann ich die info_t durch einen template-Parameter ersetzen?
>
> wenn ich anstatt info_t ein Info-Template parameter = info_t nutze
> kompilierts nicht wegen unvollstaendigem typ
>
> -was würde ich machen wenn meine Tuple-Types sind default-Konstruierbar
> ist? also der decltype-Trick nicht funktioniert?

Probier einfach mal info_t als Parameter dem Template zu übergeben. Ohne 
genaue Compilermeldung kann ich dir sonst nicht viel helfen.

// nicht getestet, aber dann nicht über decltype sonder struct mit type.
template<size_t ... I>
struct collect_infos
{
  using infos = std::tuple<info_t<I>...>;
}

[CppBert (Gast)]

hier zum oline kompilieren: https://gcc.godbolt.org/z/Hezp_U

in Zeile 24 kannst du die "Variante" einstellen

0 mein aktueller Stand
1 dein Tip - der mir sehr gefaellt aber irgendwie nicht das richtige 
macht
  collect_infos<2> => std::tuple<info_t<2>>
  collect_infos<5> => std::tuple<info_t<5>>

2 dein Tip mit info_t als Item Template-Parameter - würde vielleicht 
gehen wenn das restliche Verhalten richtig waere

[CppBert (Gast)]

info_t als Template-Parameter funktioniert so

template<template<size_t> typename Item

nicht einfach

template<typename Item

geschrieben werden

sonst funktioniert das mit der spezialisierung nicht

[CppBert (Gast)]

und so sieht der "fix" für dein collect_infos aus

an einem Beispiel orientiert:
https://stackoverflow.com/questions/39995149/expand-a-type-n-times-in-template-parameter

  template<typename>
  struct AHelper;

  template<std::size_t... S>
  struct AHelper<std::index_sequence<S...>> {
    using type = std::tuple<info_t<S>...>;
  };

  template< size_t N >
  struct A : AHelper<std::make_index_sequence<N>> {};

  static_assert(std::is_same<A<2>::type, std::tuple<info_t<0>, info_t<1> >>::value, "not the same");