Erstelle Struct/Variabel abhänig von einer Zeichenkette (ohne Switch Case)



  • Hallo,

    ich hab ein kleines Problem. Ich möchte gerne eine Strucktur oder Variabel erstellen, die vom Typ x ist.

    Der Typ steht jedoch in einem String (welchen ich aus einer Textdatei lese).

    Nun möchte ich die Variabel erstellen, jedoch ohne Switch/Case Anweisung.

    Als Switch/Case Anweisung würde das ca. so aussehen.

    switch(zeichenkette)
    {
    case(bool):
    float *boolZeiger = new bool;
    break;

    case(float):
    float *floatZeiger = new float;
    break;

    ...

    }

    Der Grund warum ich nicht mit einer Switch/Case Anweisung arbeiten kann ist, das ich ein paar hundert Struckturen handhaben muss.



  • Und was genau willst du damit anstellen, wenn dabei ein paar hundert unabhängige Ergebnisse rauskommen können, wenn ich mal so nachfragen darf?
    Ansonsten wäre das ein Idealbeispiel für eine Registry mit entsprechenden Factories, aber auch dort wirst du nicht drum herum kommen, mindestens die paar hundert Stru(c)kturen zu registrieren.



    1. Das ginge sowieso nicht mit switch, da C++ switch nur mit integralen Typen unterstützt (=keine Strings)

    2. Du kannst nicht einfach ohne Cast einen Zeiger-auf-bool in einen Zeiger-auf-float verwaldeln. Wenn du einen Zeiger-auf-Unbekannt brauchst, dann wirst du wohl nen void* verwenden müssen

    3. Du kannst std::map verwenden (z.B. std::map<std::string, FunktionsZeigerTyp>)

    4. Wie willst du die so angelegten floats/bools/structs/... dann wieder freigeben?



  • also um mein Anliegen genauer zu beschreiben.

    Ich möchte eine Funktion xyz aufrufen die als Übergabeparmeter eine Variabel von der Strucktur abc benötigt.

    Ich rufe also meine Funktion getStruct (liefert void zeiger zurück) auf und übergebe ihr den Parameter "abc" als String.

    Nun muss meine Funktion getStruct die Strucktur erstellen, mit Werten vorbelegen welche Sie aus einer Textdatei ausliest und sie mir als Zeiger zurück geben.



  • und dann? Wie willst du außerhalb deiner Funktion herausbekommen, welchen konkreten Typ dein void* hat? Das musst du doch wissen, wenn du damit was anfangen willst.
    Sieh dir mal boost::any an.



  • ja außerhalb von meiner Funktion bekomme ich dann denn zeiger auf die Strucktur von dem Typ den ich als String übergeben habe. Von diesem String ist es auch abhänig wie er meine Strucktur vorbelegt (die Daten werden aus einer Textdatei ausgelesen).



  • Deine Funktion liefert doch einen void-Pointer zurück.



  • subra schrieb:

    also um mein Anliegen genauer zu beschreiben.

    Ich möchte eine Funktion xyz aufrufen die als Übergabeparmeter eine Variabel von der Strucktur abc benötigt.

    Ist der Typ ("abc") erst zur Laufzeit bekannt?

    Ich rufe also meine Funktion getStruct (liefert void zeiger zurück) auf und übergebe ihr den Parameter "abc" als String.

    Wieso als String? Wieso nicht z.B. als Template-Parameter?

    Nun muss meine Funktion getStruct die Strucktur erstellen, mit Werten vorbelegen welche Sie aus einer Textdatei ausliest und sie mir als Zeiger zurück geben.

    Ja, soweit kein Problem, das geht immer noch schön mit std::map.
    Mit dem Löschen wird's dann halt problematisch wie schon gesagt.



  • hey,

    also es würde mir schon viel helfen wenn folgendes funktionieren würde:

    char vartyp[255] = "int";

    vartyp[255] abc;

    abc = 354; // Wert wir eig. aus Textdatei gelesen

    also er erstellt abhänig von dem Inhalt des String die Variabel abc vom Typ "int".

    Das würde natürlich ganz einfach gehen wenn ich den Inhalt des Strings mit int vergleiche (if).

    Das Problem ist jedoch das ich paar hundert Strucktypen habe und nicht für jede eine If Anweisung machen möche.



  • Das Klingt sehr nach Factories.



  • abc = 354;
    

    Für diese Zuweisung muss der Compiler allerdings wissen, welchen Code er generieren soll. Aus nem void-Pointer oder was auch immer, kann der Compiler zur Compile-Zeit nicht durch Kaffeesatzleserei erkennen, was da zur Laufzeit vorliegt.



  • ja das abc = 354; nicht funktioniert ist klar.

    Die definition der Strucktur liegt ja auch in meiner Textdatei ab genauso die Anzahl der Elemente der Strucktur...



  • Okay, dann mal Tacheles, was hast du in deiner Textdatei genau stehen und was willst du damit machen 😉



  • Du solltest mal wirklich genau dein Ziel beschreiben, sonst wird das hier weiterhin Rätselraten.

    Wo kommen die Daten her?
    Welche Art von Information ist in den Daten enthalten?
    Was willst mit den Daten machen?



  • ok dann beschreib ich mal den ganzen use case

    1. Es sind ca. verschiedenne 300 Struckturen irgendwo definiert
    2. In meiner Textdatei steht zum Beispiel unter anderem drin:
    /begin
    structest
    int x = 5
    char p = c
    strucandere <- Zeiger auf andere Strucktur
    /end

    3. Die Funktion bekommt als Parameter übergeben das Sie nun eine Strucktur vom Typ "structest" haben möchte. Den zurück gelieferten void zeiger cast ich dann passend.

    So nun muss die Funktion dynamisch ein Element der Strucktur "structest" erstellen. Woher Sie das weiß? Ich übergebe den Namen "structest" als String der Funktion.

    Ich könnte natürlich jetzt über if/ bzw. switch/case Anweisungen eine Selektierung vornehmen, jedoch macht das bei ca. 300 Struckturen mit einigen Komponenten kein Spaß und kostet viel Zeit.

    Wenn dann nun die Strucktur erstellt worden ist (keine Ahnung wie^^), muss er zeiger_structest->x = 5 machen. Und natürlich wird das x auch aus der Textliste gehollt und nicht hardcoded abgelegt. Somit währe meine Funktion super dynamisch...

    Alternativ kann ich natürlich auch die Funktion so defieren, das ich zuerst die Strucktur definiere, und dann den Zeiger der Strucktur meiner Funktion übergebe.
    Über typdef bekomme ich ja dann in meiner Funktion den Namen des Struckturtypes zurück.

    Aber wie kann ich dann auf die einzelnen Komponenten zugreifen, ohne zu wissen wie diese heisen.

    Gibt es die möglichkeit zu sagen, geh einfach zum nächsten Komponenten? Die Anzahl der Komponenten bekomme ich ja aus der Textdatei herraus.



  • It0101 schrieb:

    Wo kommen die Daten her?
    Welche Art von Information ist in den Daten enthalten?
    Was willst mit den Daten machen?

    Die Datei wird von mir geschrieben und ich lege die Definition der Datei fest. Später soll diese über ein GUI Programm geändert werden können.

    Was mit den Daten gemacht wird habe ich weiter oben beschrieben.



  • man kann das natürlich machen, aber das hat dann nix mehr mit struktur_x->y zu tun sondern eher mit root->GetStruktur( "x" )->FindValue( "y" ); und dann brauchst du in den zurückgegebenen Typen jede Menge Konversionscode von String zu Typ usw. usf.

    Was willst du denn mit deinen "Struckturen" machen, sobald sie mal aus der Datei gelesen wurden und mit den Daten daraus gefüllt wurden?



  • ich möchte die Strucktur dann einer Funktion übergeben bzw ich übergebe dann den Zeiger der Strucktur an eine Funktion...



  • Naja, ich weiß ja nicht... Man kann sicherlich binärkompatible "Struckturen" dynamisch im Speichern erzeugen (zumindest plattformabhängig)... Aber ich erkenn den Sinn nicht... man müsste dem "Strucktur"-Interpreter ja wieder eine Definition liefern, die im Quellcode sowieso schon vorhanden ist... Naja, mach du da mal mit deinen "Struckturen".



  • 😃


Log in to reply