[C++] Struct über Socket senden

Avenger

Avenger

0
Ich versuche, die struct

Code: 
struct TestS
{
    int a;
    int b;
    char* c;
};

mit folgender Anweisung über einen Socket an einen Clienten zu senden:

Code: 
send( Socket, ((char*)&TestS), sizeof(TestS), 0 );

und mit folgender Anweisung versuch ich, die Struct beim Clienten zu empfangen:

Code: 
TestS TestS2;
recv( s, ((char*)&TestS2), sizeof(TestS2), 0 );

Wenn ich nun die Struct beim server volllade (mit TestS.a = 5, TestS.b = 10 und TestS.c = "Test" ), dann kann ich beim Clienten nur die zwei ints empfangen, der char* ist leer. Wenn ich nun die vollgeladene Struct erneut sende, kommen nicht 5 und 10 an, sondern irgendwelche Wirren Zahlen, und das Programm steigt danach aus.
Ich denke, alles notwendige wurde genannt.

mfg
 
Was mir als nicht C++ler auffällt:

Code: 
send( Socket, ((char*)&TestS), sizeof(TestS), 0 );
Wie groß ist TestS? Je nach Compiler unterschiedlich, aber vermutlich 12 Bytes (3 DWORDs - Wert1,Wert2,Pointer)),
Und Du sendest ja nicht den Text, der sich gar nicht in der Struct befindet, sondern den Pointer darauf ;).Sprich: Int1, Int2 und Pointer auf Chararray - aber NICHT das Array selbst.


Edit: korrektur: afaik muss recv() nicht alles "auf einmal" emfpangen.

Was Dein zweites Problem angeht - kann ich Dir leider nicht sagen, da ich kein C++ler bin ;). Allerdings würde eventuell mehr Code trotzdem guttun - vor allem wo Du die Struct emfpängst. Da "recv" nicht alles aufeinmal emfpangen muss, müsstest Du Dir eine Emfpangs-Schleife basteln, bzw. zu Testzwecken kannst Du Dir auch einfach die Anzahl der emfpangegen Bytes ausgeben lassen.
 
Danke CDW. Ich werde mal unter Google nach anderen Lösungen suchen, oda schaun, wie es andere leute angestellt haben.
 
Sag mal, Avenger, warum referenzierst Du ein Zeichen, wenn Du 'n Struct meist?


Code: 
send( Socket, ((char*)&TestS), sizeof(TestS), 0 );

Der "Char*" Zeiger sollte auf den Anfang der Struktur zeigen,
also ein Zeiger auf Deine Struktur sein.


Also so etwa:


Code: 
struct sendepuffer
{
    int a;
    int b;
    char* c;
} TestS ;

// jetzt muss der Sendepuffer noch gefüllt werden!

TestS.a=1;
TestS.b=1;
TestS.c="Golgotha";

//... und jetzt übertragen ...

send( Socket, ((sendepuffer*)&TestS), sizeof(TestS), 0 );

Achtung, jetzt musst Du probieren, ich hab'mir die Funktion "Send"
nicht genau angesehen, wenn dies nur "Char" verarbeiten kann,
musst Du "von Hand", wie schon 'n goiler Hacker hier festgestellt hat
Zeichen fürZeichen übertragen.


Golgy.
 
Hallo Avenger,

die Variable "char *" in der Struktur ist das Problem.

Wenn Du sie initialisierst (z.B. durch den Ausdruck : char = "zeichenfolge"), dann enthält die Variable nicht etwa die Zeichenfolge, sondern nur die Adresse, an der sich die Zeichenfolge befindet.

Da der Server und der Client niemals im gleichen "address-space" laufen (sind schliesslich zwei verschiedene Prozesse), versendest Du immer einen nicht (bzw. falsch) initialisierten Zeiger.

Deshalb darf man generell bei Server-Client-Anwendungen niemals Zeiger versenden.

Probiere mal folgendes :

Initialisiere die Struktur einmal mit einer langen Zeichenfolge und einmal mit einer kurzen Zeichenfolge.

Dann lasse Dir via sizeof() anzeigen, wie gross sie jeweils ist.

Sie wird jedesmal 12 Bytes sein.

So, nun eine mögliche Lösung :

Ändere die Variable "char *" in "char [20]".

Dann dürfte das Problem beseitigt sein.
 
@merker:
Hab ich wohl übersehen, aber danke, jetz gehts.. Ich war wohl schon sehr verschlafen, als ich den Code gemacht habe, denn mir ist gerade aufgefallen, dass ich TestS.c erst nach dem senden mit daten gefüllt habe >.<

danke an alle, mfg
 
Um antworten zu können musst du eingeloggt sein.
Zurück
Oben