Henne <-> Ei Problem!

[Meik J. (tidemic)]

Frohe Oster, sehr geehrte Community!
Ich schreibe gerade auf dem Arduino ein kleines
Programm. Und möchte über ein Terminal (Putty)
Variablen ändern Funktionen aufrufen durch Verzeichnisse
navigieren.

Damit ich nicht alles in Spaghetti schreiben wollte.

Jetzt zu meinem Problem:
Bspl:

template <typename T, typename P>
class Container
{
 public:
 String Name;//Terminal Name des Wertes
 T Value;//Enthaltener Wert
 P *Pointer;//Soll auf das nächste Container Objekt verweisen ! ;)
};

Und da habe ich jetzt natürlich das Problem:

Container<int,Container < bool,Container <.............

Ich wollte halt von diesem Container auf den nächsten verweisen der 
seiner
Seits ja auch auf einen Verweist usw!


Habe mich ein weinig fest gefranzt.
Kreative neue Denkansätze erwünscht.

Gruß Meik

[g457 (Gast)]

..ich sehe zwar keine konkrete Frage aber die Antwort ist trotzdem 
Vererbung und Abstraktion.

HTH

[Max H. (hartl192)]

Meik Juenke schrieb:
> Und da habe ich jetzt natürlich das Problem:
>
> Container<int,Container < bool,Container <.............
>
> Ich wollte halt von diesem Container auf den nächsten verweisen der
> seiner
> Seits ja auch auf einen Verweist usw!
Und was ist dabei das Problem? Ist eine ganz normale verkettete Liste

[Meik J. (tidemic)]

Danke für die schnellen Antworten

Also doch Tippen..

Das Problem ist das es verdammt viele verschiedene Typen durch
die Template Kombinationen zustande kommen.
 Halt nicht einfach Vektor und gut.

Eine Template das als Parameter ein Template erhält das seiner seits 
weider
ein Template erhält....

[Dr. Sommer (Gast)]

Kennst du schon std::tuple ?
http://en.cppreference.com/w/cpp/utility/tuple

Da du aber scheinbar einen Container brauchst der viele Variablen 
unterschiedlichen Typs enthält, kann man da nicht viel machen, denn du 
musst ja alle Typen irgendwo angeben...

[Leidensgenosse (Gast)]

So etwas hab ich in Java gesehen. Listen von Maps von Listen von Listen 
von Maps oder so ähnlich. Bin zu der Meinung gekommen: Am besten den 
Erfinder erschlagen und von Grund auf neu anfangen.

[Vlad T. (vlad_tepesch)]

QMap<QString, QVariant>
oder eine beliebige liste.

bzw eine boost variante des ganzen.

Prinzipiell ist es meist eine schlechte Idee, die Containerstructur (bei 
dir Link auf nächstes Element) mit den Daten (bei dir Key-Value-Pair) zu 
vermixen.

Wenn man das ganze unbedingt selber schreiben will, dann eine Klasse, 
die genug speicher für den größsten möglichen Typen enthält (oder wenns 
noch abstracter sein soll, einen void pointer) und ein feld, was den Typ 
speichert.

mittels Template zugriffsfunktionen, die den Typ checken (zb via type 
traits) kannst du dein OBjekt wieder rausholen.

template <class T>
class MyVariantTypeId{
enum { id = -1 };
}


template <>
class MyVariantTypeId<bool>{
  enum { id = 0 };
}
template <>
class MyVariantTypeId<int8>{
  enum { id = 1 };
}
class MyVariant
{
public:
  template <class T> 
  bool set( const T& v){
    if ( sizeof(T) <= MAX_VAR_BYTES){
      m_type= MyVariantTypeId<T>::id;
      *((T*)m_data) = v;
       return true;
    }
    return false;
  }

  template <class T> 
  const T* get(){
    m_data = MyVariantTypeId<T>::id;
    if (MyVariantTypeId<T>::id == m_type){
       return ((T*)m_data);
    }
    return nullptr;
  }

private:
  int     m_type;
  uint8_t m_data[MAX_VAR_BYTES];
}

Edit: der Code ist jetzt nur so runtergetippt, um das Prinzip zu 
verdeutlichen. Kann sein, dass er fehler enthält. Sowohl syntaktischer, 
als auch logischer Natur

[Daniel A. (daniel-a)]

Ist soetwas gewünscht?

class basic_container {
  public:
    String Name;//Terminal Name des Wertes
    basic_container *Pointer;//Soll auf das nächste Container Objekt verweisen ! ;)
};

template <typename T>
class Container : public basic_container {
  public:
    T Value;//Enthaltener Wert
};

[Meik J. (tidemic)]

Moin,
ihr habt mir sehr weiter geholfen. Ich habe zwar keinen der Vorschläge
direkt umgesetzt. Aber der "Denkanstoß" kam!
Und ich habe mein altes Konzept über den Haufen geschmissen!
An dieser Stelle erstmal danke! :)

Da die Befehle vom Terminal als String weiter verarbeitet werden.
Setze ich Polymorphie ein.
Eine Basis Klasse die virtual Methoden hat und als Parameter String
erwartet.
Und von ihr zB eine Template Klasse ableite.
So kann immer über den gleichen Typ (Basis) Zeiger auf alle relevanten
Methoden der verschiedenen Objekte zugegriffen werden.

So die IDEE! ;)