Du bist nicht angemeldet.

Stilllegung des Forums
Das Forum wurde am 05.06.2023 nach über 20 Jahren stillgelegt (weitere Informationen und ein kleiner Rückblick).
Registrierungen, Anmeldungen und Postings sind nicht mehr möglich. Öffentliche Inhalte sind weiterhin zugänglich.
Das Team von spieleprogrammierer.de bedankt sich bei der Community für die vielen schönen Jahre.
Wenn du eine deutschsprachige Spieleentwickler-Community suchst, schau doch mal im Discord und auf ZFX vorbei!

struct und socket

Werbeanzeige

Anonymous

unregistriert

21

04.04.2009, 14:17

Ich benutze primär in meinen Produkten nur Standard C-Funktionalitäten und systemnahe API-Funktionen (Posix, Win32). Von Zusatz-Libs wie MSXML, TinyXML, ragnet, STL usw. halte ich persönlich nichts, da sie mehr Probleme für mich bereiten als Nutzen bringen.

Meine XML-Funktionen sind rein C geschrieben (C++ ist nur der Wrapper), arbeiten Sequenziell und möglichen Random-Zugriff (Also nicht erst alles in den Ram lesen und gucken was geht) und sind über das 40x schneller als TinyXML und das 10x von MSXML. Versuch mal eine 30 GByte XML-Datei mit TinyXML zu lesen oder mit MSXML, da gehen die Teile mehr als nur in Brand auf.

Gerade in meiner Branche wo ich viel mit Netzwerk, Datenbank und Datenaustausch arbeite muss ich sagen, das XML dort eher sehr wenig eingesetzt wird, weil wir hauptsächlich Daten haben die ab einer Größenordnung von 3 GByte+ beginnen und Zeitversetzt versendet werden in mehreren Teilen.

Dort XML zu verwenden wäre der absolute Show-Down für das Netzwerk.

VuuRWerK

Frischling

Beiträge: 59

Wohnort: Dresden

Beruf: Softwareentwickler

  • Private Nachricht senden

22

04.04.2009, 14:43

Ok, das sind aber wirklich ganz andere Dimensionen wo sich XML nicht mehr lohnt da hast Du mein full Ack ;)
TinyXML und MSXML kenne ich nicht und nutze ich auch nicht ich arbeite eher mit Xerces oder einen in Spirit1x geschriebenen Parser, besagter überraschte mich mit oben genannter Performance. Ansonsten entwickle ich gerade ebenfalls einen eigenen aber mit Spirit2x und kompletten DOM, mal schaun wie sich da die Performance entwickelt. Aber das wird langsam OT hier :)

Also wenn der Threadersteller noch was lernen will dann empfehle ich die Version mit boost::serialization. Ansonsten Protocol Buffer von Google (macht einen netten Eindruck).

Gut Schuß
VuuRWerK ;)

killmichnich

unregistriert

23

04.04.2009, 14:58

ok danke euch ich werds mir mal anschaun und versuchen zu verstehen

chriss

Alter Hase

Beiträge: 624

  • Private Nachricht senden

24

05.04.2009, 01:28

Warum so umständlich?

Wenn du dich auf einfache Datentypen beschränken kannst geht es viel einfacher

Struktur

Quellcode

 
1
2
3
4
5
6
7
8

struct Move
{
  unsigned char packetId;
  int objectId;
  foat posX;
  float posY;
  float posZ;
};


Angenommen du hast jetzt schon eine Verbindung und den Socket "socket" kannst du es so senden

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11

Move move;

// hier jetzt die Werte eintragen


// Puffer erstellen und Daten Übertragen (ich gehe hier nur davon aus das maximal 1024 Byte benutzt werden <-- eventuell anpassen)
char buffer[1024];
memcpy((void*)&buffer,(void*)&move,sizeof(move));

// Daten senden
int result = send (socket, buffer, sizeof(move), 0);


Der Code ist jetzt auf das wesentliche minimiert (bevor sich jetzt wer beschwert was ich doch so alles "vergessen" habe).
Mit Sockets habe ich das so noch nicht gemacht aber mit Raknet funktioniert das sehr gut (dort braucht man allerdings das Konstante Char Array nicht).



EDIT: Beim Empfangen musst du übrigens nur das erste Byte betrachten und weißt dann sofort in welche Struktur du deine Daten Casten musst.

Anonymous

unregistriert

25

05.04.2009, 01:31

Stopf noch 2 Strings rein vom Typ std::string und dann gucken wir mal weiter ;)

chriss

Alter Hase

Beiträge: 624

  • Private Nachricht senden

26

05.04.2009, 01:34

Zitat von »"unsigned long"«

Stopf noch 2 Strings rein vom Typ std::string und dann gucken wir mal weiter ;)

Jo, deswegen habe ich ja geschrieben das es geht wenn er sich auf einfache Datentypen beschränken kann.
Alles aus STD sowie generell Objekte funktionieren da nicht.

Also eignetlich nur:
char
short
int
long
float
double

+ sämmtliche Variationen die man mit unsigned usw. erstellen kann

killmichnich

unregistriert

27

05.04.2009, 14:02

"EDIT: Beim Empfangen musst du übrigens nur das erste Byte betrachten und weißt dann sofort in welche Struktur du deine Daten Casten musst.
"

könntest du das vllt ein wenig genauer erläutern? :oops:

Anonymous

unregistriert

28

05.04.2009, 14:36

Stichwort: Präambel

Nox

Supermoderator

Beiträge: 5 272

Beruf: Student

  • Private Nachricht senden

29

05.04.2009, 15:34

@chriss bleibt nur die align-Geschichte zu beachten ;) .

RakNet kennt besitzt ja eine Streamklasse, die recht intuitiv ist (und die von xardias vorgeschlagene Variante von google arbeitet wahrscheinlich ähnlich). Im Prinzip macht die Streamklasse nichts anderes als die von Steven77 in eine Klasse unterzubringen unter der Nutzung von chriss Vorgeschlagenen Ansatz.
Weniger Text mehr Code.
Nativer Ansatz von chriss

C-/C++-Quelltext

 
1
2
3
4
5
6
7

size_t offset = 0;
char* buffer = new buffer[bekannte_größe];
memcpy(buffer + offset, &varible1, sizeof_variable1); offset += sizeof_variable1;
memcpy(buffer + offset, &varible2, sizeof_variable2); offset += sizeof_variable2;
memcpy(buffer + offset, &varible3, sizeof_variable3); offset += sizeof_variable3;
...
senden(buffer, bekannte_größe);

Vorteil: sehr einfach und direkt ersichtlich was sache ist.
Nachteil: endiness wird nicht beachtet und viel Codewiederholung. Außerdem muss man ggf. den Speicher von Hand vergrößeren und Container(wie strings, arrays, listen usw.) von Hand serialisieren.

Streamklassen Variante:

C-/C++-Quelltext

 
1
2
3
4
5
6

Stream str;
str.Write(variable1);
str.Write(variable2);
str.Write(variable3);
...
senden(str.buffer(), str.size());

Oder ggf sogar:

C-/C++-Quelltext

 
1
2
3
4
5
6

Stream str;
str << variable1;
str << variable2;
str << variable3;
...
senden(str.buffer(), str.size());

Beide Varianten machen aber im Prinzip das gleiche wie die erste :). Somit versuchen wieder alle das gleiche zu sagen ;).
PRO Lernkurs "Wie benutze ich eine Doku richtig"!
CONTRA lasst mal die anderen machen!
networklibbenc - Netzwerklibs im Vergleich | syncsys - Netzwerk lib (MMO-ready) | Schleichfahrt Remake | Firegalaxy | Sammelsurium rund um FPGA&Co.

killmichnich

unregistriert

30

05.04.2009, 19:58

also ich habs jetzt mal so probiert:


C-/C++-Quelltext

 
1
2
3
4
5
6
7
8
9
10
11
12
13

struct spieler
{
char name[18];
int xpos;
int ypos;
};
spieler sspieler;

        char text[1024];
        sspieler.xpos=xpos;
        sspieler.ypos=xpos;
        memcpy((void*)&text,(void*)&sspieler,sizeof(sspieler));
        internet.Send(text);

und da wo ichs empfang eben andersrum.
Am Anfang klappt das ganze auch, da wird mein name weitergeschickt und auch die koordinaten (0|0), nur wenn ich dir koordinaten veränder komm am anfang immer noch 0 und dann kommen ganz wirre zahlen raus ... :(

Werbeanzeige