Jetzt habe ich ein Integer versendet:

int *i = new int (12);
		send(server->connectedSocket,(const char*)i,4,0);

das funktioniert auch.

Nun kann ich den Integer folgendermaßen empfangen:

int *i = new int;
		int laenge=0;
		while (laenge!=4)
		{

			laenge = laenge+recv (s,(char*)i,4-laenge,0);

		}

	cout << *i;

Nun mein Problem:
Was passiert, wenn z.B nur 3 Byte empfangen wurden.
Dann wird send(...) ja das fehlende Nachladen, bis laenge==4 ist.
Nun wird beim 2. laden dem send(...) ja wieder die Adresse des int *i übergeben.
Dann wird die Funktion ja das erste byte, welches es reingeschrieben hat überschreiben (denke ich zumindest).

Dann habe ich mir gedacht ich umgehe das ganze, in dem ich einfach ein char[4] benutze, also so:

char *i = new char[4];
		int laenge=0;
		while (laenge<4)
		{

			laenge = laenge+recv (s,i+laenge,4-laenge,0);

		}

Jetzt kann ich angeben, an welche Stelle nachgeladen werden muß (wegen i+laenge)
Das ging ja vorher nicht, da ein +1 ja schon um 4 byte weiterzählt bei int.
Allerdings gelingt es mir jetzt überhaupt nicht mehr das char[4] in ein int umwandeln.
Ich habe schon alles von der Seite
http://www.c-plusplus.net/forum/viewtopic-var-t-is-39488.html
ausprobiert, aber nichts scheint zu funktionieren.

Wie lößt man dieses Problem?

Wie mache ich das denn bei einem nicht primitiven Tadentyp?
Die ersten 4 sind ja die die zeigeradresse. Diese mitzuübertragen ist ja unsinnig. Wenn ich dann aber den char* so umwandle (wie oben beschrieben) überschreibe ich anscheinen auch die Adresse des Objektes was zu Abstürzen führt.
Wie kann ich denn noch diesen Fall lösen?

Wie mache ich das denn bei einem nicht primitiven Tadentyp?

genauso falls du mit nicht primitiver tadentyp ein struct meinst.

struct test
{

   int typ:
   int groesse;
   int Nutzdaten;

//Methoden
}

Wenn ich jetzt sizeof(test) schreibe, müßte ja eigentlich 12 dabei rauskommen.
Es kommt aber 16 herraus.

Ich habe schon herausgefunden, dass die ersten 4 byte irgend eine interne Bedeutung haben.

Wenn ich diese Mitübertrage und und im neuen struct beim Empfänger mit eintrage, stürzt dieser ab.

Ich habe also beim Senden dies nicht mit übertragen:

[cpp]
test *t = new test();
send(server->connectedSocket,(const char*)t+4,sizeof(t)-4,0);

Jetzt kommen beim Empfänger ja nur 12 Byte an. Auch wenn ich diese an die richtige stelle 4-16 eines char[16] kopiere und dann das Strukt wie im vorherigen Beitrag das ist erstelle, überschreibe ich die 4 Byte.
Wie kann ich diese vorher auslesen und dann wieder eintragen?
Oder wie kann ich sonst mit dem problem umgehen?

test t = (test)(buffer + 4);

Aber warum erzeugt Virtuell diese 4 Byte?
Was steht da drin?

Zwar kopierst du die ersten 4 Byte nicht mit, aber dafür kopiert deine Version die 2ten 4 Byte auf die ersten 4 Byte, in der die Informationen von Virtuel steht usw.

Du kopierst so:

4 Byte virtuel   4 Byte typ     4 Byte Laenge   4Byte werte

                     |             |                 |
                     V             V                 V  

               4 Byte virtuel   4 Byte typ     4 Byte Laenge   4Byte werte

struct test
{
   int typ;
   int groesse;
   int Nutzdaten;

   void* GetDataPtr() { return &typ; }
   int GetDataSize() { return sizeof(*this)-4; }
};

test *t = new test();
send( server->connectedSocket, t->GetDataPtr(), t->GetDataSize(), 0 );

Müsste das nicht funktionieren? Und beim Einlesen das selbe?

test obj;
memcpy((char*)&obj + 4, ..., ...);

aber so das ist alles so eine frickelei! an deiner stelle würde ich boost::serialization nutzen.

aber so das ist alles so eine frickelei!

Du heißt doch 'friggler'

struct test
{
   int typ;
   int groesse;
   int Nutzdaten;

   void* GetDataPtr() { return &typ; }
   int GetDataSize() { return sizeof(*this)-4; }
};

Müsste das nicht funktionieren? Und beim Einlesen das selbe?

LOOOOOL, Was soll das denn darstellen ?=?

LOOOOOL, Was soll das denn darstellen ?=?

Wollte es ja erst so posten:

struct test
{
   int typ;
   int groesse;
   int Nutzdaten;
;

test *t = new test();
send( server->connectedSocket, &t->typ, sizeof(test)-4, 0 );

aber dann dachte ich, dass er es mit eingebauten Funktionen einfacher findet

aber dann dachte ich, dass er es mit eingebauten Funktionen einfacher findet

OK, ok, sah nämlich sehr utopisch aus ...
BTW: Das sind Methoden, keine Funktionen .

Danke an alle!

Badestrand schrieb:

aber dann dachte ich, dass er es mit eingebauten Funktionen einfacher findet

OK, ok, sah nämlich sehr utopisch aus ...
BTW: Das sind Methoden, keine Funktionen .

das sind Memberfunktionen, keine Methoden.

[...]
das sind Memberfunktionen, keine Methoden.

lol, nur dumm, dass Memberfunktionen, das gleiche sind wie Methoden ...