3. Struct per Netzwerk übertragen

Struct per Netzwerk übertragen

  • R

    Hallo Leute,

    ich frage mich gerade ob es nicht möglich ist eine von mir selbst definierte Sruktur in einen byte-stream umzuwandeln und dann zu übertragen??

    Ist soetwas möglich, und halbwegs einfach für senden & Empfang zu realisieren?

    MfG, Rodney

    0
  • E

    Kannst ja einfach in ein char-Array casten und beim empfänger wieder zurück
    casten.

    0
  • R

    EnERgYzEr schrieb:

    Kannst ja einfach in ein char-Array casten und beim empfänger wieder zurück
    casten.

    sowas funktioniert??? Muss ich mir meinen Cast dann nicht selber schreiben?

    0
  • P

    Nö du bekommst nen unsgned char * und castest deine Structur drauf.

    Funktioniert sicher mit C-Style-Casts.

    Das ganze gilt natürlich auch vice versa @struct => unsigned char *

    0
  • P

    Noch eine Anmerkung. Ich würde an deiner Stelle allerdings einem Textprotokoll den Vorzug geben. Bei der Übertragung und beim versenden und wieder zusammensetzen gibt es schon einges zubeachten. Und damit mein ich nicht nur die byteorder.

    0
  • R

    was gibt es dort denn bestimmtes zu beachten?

    Könnte jemand vielleicht einen kurzen Codeauschnitt geben?

    0
  • R

    😕

    0
  • R

    könnte vielleicht jemand einmal einen kleinen Codeauschnittgeben wie ich das ganze erstmal in char herein und dann wieder herauscasten kann?

    struct meinestruktur {
    int x;
    int y;
    char name[50];
    int richtung;
}
    0
  • M
     

    struct meinestruktur m1;
unsigned char * zeigeraufchar;
struct meinestruktur * zeigeraufstruct;

zeigeraufchar=(unsigned char*)&m1;
zeigeraufstruct=(struct meinestruktur *)zeigeraufchar;
    0
  • R

    ich bins nochmal:

    warum funktioniert folgender Code nicht (Zugriffsverletzung beim Ausführen)

    void send_message(char id, char typ, char richtung, int x, int y, char spielername[10]) { // Mit dieser Funktion werden Nachrichten versendet

	nachricht msg;
	msg.id = id;
	msg.typ = typ;
	msg.richtung = richtung;
	msg.x = x;
	msg.y = y;
	strcpy(msg.nickname,spielername);

	send(s,(char *)&msg,sizeof(nachricht),0);
}

    void recvstring(nachricht *msg) { // wird bei WM_SOCKET aufgerufen...

	char *buffer = 0;
	recv(s,buffer,sizeof(nachricht),0);
	msg = (nachricht *)buffer;
	}

};

    MfG, Rodney

    0
  • R

    hat keiner ne Ahnung?

    0
  • R

    was würde passieren, wenn im buffer den recv() abholt erst ein paar Zeichen stehn würdn und nicht soviele, dass das Struct vollständig übertragen wurde?
    Würde das Prog dann abstürzen? Wie bekomme ich raus wieviele bytes im buffer sind bevor ich sie abrufe?

    0
  • S

    buffer hat keinen speicher und du willst was reinschreiben... kann nicht gut gehen.

    0
  • R

    Shade Of Mine schrieb:

    buffer hat keinen speicher und du willst was reinschreiben... kann nicht gut gehen.

    wie reservier ich denn speicher fürn nen char*, ich arbeite sonst immer nur mit nullt. Char-arrays... 🙄 😕

    0
  • K
     

    char *ChVar;

// z.B. für 1024 chars:
ChVar = new char[1024];

// aber auch unbedingt Speicher wieder freigeben (wird nicht automatisch
//gemacht!!!!!!)

delete [] ChVar;

// und dannach am besten auf NULL setzten !!!
ChVar = NULL;
    0
  • R

    ok, ich reserviere jetzt speicher aber das Prob besteht immer noch...
    Das Programm stürztzt in diesen Funktionen ab

    0
  • ?
     

    //Aufrufen z.B. mit 
//  nachricht msg; // hier wird der Speicher reserviert
//  recvstring( &msg);

void recvstring(nachricht *msg) { // wird bei WM_SOCKET aufgerufen... 
//    char *buffer = 0; 
    recv(s, msg, sizeof(nachricht),0); // direkt nach msg schreiben
//    msg = (nachricht *)buffer; 
    }
    0
  • R

    direkt nach msg schreiben geht ja nicht, weil ich nen Cast brauche...
    Sonst meckert jedenfalls der compiler

    0
  • R

    😕

    0
  • R

    @Kingrabbit

    Code Strukturen mit folgenden Muster (was du vorschlaegst)

    // ... komm von irgendwo 
{
    // nu brauch ich ne feste anzahl an SPeicher : 
    char * buffer = new char[1024]; 
    // ... tu irgendwas 

    //nu brauch ich Speicher nimmer 
    delete[] buffer;
    buffer = NULL;
}

    Machen ned viel sinn, besser gesagt sind unperformant
    besser:

    // ... komm von irgendwo 
{
    // buffer besser statisch anlegen 
    char buffer[1024];
    // genu so benutzen wie vorher. 
}

    der statische buffer wird nun auch nur angelegt, wenn in den code-abschnitt kommst ....
    dynamisch speicher allokieren solltest du nur wenn :
    du mehrere Objecte unbestimmter anzahl allokieren musst (container)
    die lebensdauer deiner objecte den scope deiner erzeugenden funktion ueberschreiten (smartpointer) oder die erzeugten objecte unbestimmten Types sind (implementierung verborgen, object - factory usw zaehlen hier rein).
    Abhaengigkeiten aufloesen willst (PIMPL idom)

    Das wars eigentlich schon ....
    Sogar polymorhy kann man mit statischen objekten betreiben ... new und delete sind nu mal schweineteuer ....

    @Rodney
    prinzipiell:

    Du willst streamen, dann benutze auch streams 🙂
    nim dir nen stl stream her, ueberlade die << >> operatoren fuer deine Klasse ... dann uebertrage den stream, das design duerfte etwas zukunftstraechtiger sein ....

    nutze keine c-casts ... nim reinterpret_cast wenn mit c++ arbeitest ....
    zum copieren auf auf statisch allokierte speicherbereiche nimm strncopy (sicherer)

    "char spielername[10]" in ner parameterliste ? das funzt ? besser "const char * " und die lanege auch noch als parameter ....

    Schreibst du eigentlich c oder c++ ??
    Sieht mir so eher nach c aus ...

    Ciao ...

    0
  • R

    ich schreib eignetlich son ziemliches c/++ gemisch...
    Sieht man ja auch am code.

    Aber prinzipiell müsste es doch auch mit den Funktionen gehen de ich verwendet habe oder?? 😕

    0
Anmelden zum Antworten