verschiedene Variablentypen in einen Bytestream kopieren



  • Hallo Leute,

    ich möchte über sockets Nachrichten mit folgendem Aufbau versenden:

    [CHAR][CHAR][CHAR][INT][INT][char*]['#']

    Wie kann ich diese ganzen Variablen zuerst in einen String kopieren, und nach dem Empfangen wieder in die ursprünglichen Variablen zurückkopieren?

    char* kann unterschiedlich lang sein, mit # wird das Paket beendet...

    MfG, Rodney



  • Warum so kompliziert? Benutze doch einfach eine Struktur.

    mit der Funktion sprintf() kannst du alles mögliche in einen String kopieren. Aber das auslesen wird dann schwer, es sein den du benutzt Trennzeichen



  • Wenn der Aufbau des Strings immer gleich ist, hast du es ziemlich einfach beim Auslesen.
    Amsonsten musst du dir irgendwelche Trennzeichen einfallen lassen und einen Parser schreiben.



  • der Aufbau ist immer gleich, nur der char* string ist halt unterschiedlich lang...
    Trennzeichen wollte ich eigentlich vermeiden, aber man müsste doch wenn man weiß wie groß ein int etc ist das ganze wiederherstellen können?



  • keiner ne Ahnung wie man das machen könnte?



  • warum nicht einfach so

    struct
    {
        char a; //[char]
        char b; //[char]
        char c; //[char]
        int d; //[int]
        int e; //[int]
        char* str; //[char*]
        char del; //['#']
    }
    


  • und dann die struktur in nen char* casten, verschicken und wieder zurückcasten?



  • Wenn du die Daten so speicherst, das jede eine feste Menge char's bekommt, also z.B. ein int 5, dann kannst du es auslesen, weil du weißt, das int 5 Zeichen bekommt. Andernfalls kannst du nicht trennen. Da die Rheienfolge bekannt ist, weißt du, wann welches kommt.



  • UPS DOPPEL POST *g*



  • randa schrieb:

    Wenn du die Daten so speicherst, das jede eine feste Menge char's bekommt, also z.B. ein int 5, dann kannst du es auslesen, weil du weißt, das int 5 Zeichen bekommt. Andernfalls kannst du nicht trennen. Da die Rheienfolge bekannt ist, weißt du, wann welches kommt.

    ????

    Das ist imo quatsch.

    int ist unter 32-Bit Systemen meisten ein 32-Bit typ d.h. 4 Byte = 4 char weil 1 char = 8 Bit = 1 Byte

    das ist so gesehen fest.
    Das einzige Problem das er haben könnte ist das char* denn das kann ja beliebig lang sein! Wenn er dies auf sagen wir mal 256 festlegt (ich weiß ja net was da drin stehen soll) könnte es gehen

    Dann müsste das so aussehen:

    struct foo
    {
        char a; //[char]
        char b; //[char]
        char c; //[char]
        int d; //[int]
        int e; //[int]
        char str[256]; //anstatt char* str;
        char del; //['#']
    }
    

    dann kann er es in eine Datei oder einen Stream schreiben:

    foo foo_obj;
    std::ofstream out_file("afile.out",std::ios::binary);
    out_file.write((char*)&foo_obj, sizeof(foo));

    MfG



  • ein char* ist auf 32Bit Plattformen 4byte groß



  • SirLant schrieb:

    ein char* ist auf 32Bit Plattformen 4byte groß

    der Pointer ist so groß

    Aber wie groß ist der inhalt?

    🙄



  • so groß: std::strlen (str);



  • eViLiSSiMo schrieb:

    Das ist imo quatsch.

    Nicht, wenn es so wäre, wie ich verstanden hab. 🙂

    Aber ich hab's falsch verstanden 😃


Anmelden zum Antworten