DWORD WINAPI ThreadFuncGetBroadcast() 
{ 

	while(1)
	{

		char *t=new char[100];

	//	rc=recvfrom(ServerSockListenBR,t,100,0, (struct sockaddr *) &AddrServer, &size);

		//if(rc != -1 && StrComp(GameName,t)) //SendBroadcast
		{
			_Broadcast* s1Struct1=new _Broadcast;

			sprintf_s(s1Struct1->GameName,GameName);
			dat* s2Struct1=new dat;
			s2Struct1->k=0;

			sprintf_s(s2Struct1->mes,"HALLOOOO!!!");

			s1Struct1->Rest=(char*)s2Struct1;

			sendto(ClientSockSend,(char*)s1Struct1,sizeof(_Broadcast)+sizeof(dat),0, (struct sockaddr *) &AddrClient, sizeof(AddrClient));

			FILE*f=fopen("c:\\delta.txt","wb");
			fwrite((char*)s1Struct1,sizeof(_Broadcast)+sizeof(dat),1,f);
			fclose(f);

			delete s2Struct1;
			delete s1Struct1;
		}
		delete t;

	}

   return NULL; 
}

Seltsamerweise geht es nur, wenn ich statt "c:\\delta.txt" "c:\\delta3.txt" schreibe...

CLR ändert auch (manchmal) das Verhalten...

Hiermit werden die Strukturen geladen:

s1Struct2=new _Broadcast;
    s2Struct2=new dat;
    s1Struct2->Rest=(char*)s2Struct2;
		rc=recvfrom(ServerSockListen,(char*)s1Struct2,sizeof(_Broadcast)+sizeof(dat),0, (struct sockaddr *) &AddrServer, &size);

    FILE*f=fopen("c:/delta.txt","rb");
    fread((char*)s1Struct2,sizeof(_Broadcast)+sizeof(dat),1,f);
    fclose(f);

    iprintf(s2Struct2->mes);

struct _Broadcast
{
	char HOST[128];
	char GameName[100];
	char* Rest;

};

struct dat
{
	int k;
	char mes[100];
};

Seht ihr vielleicht welche Speicherfehler ich mache und/oder wie ich verschachtelte Strukturen besser sende/speichere ?

Bin für jede Hilfe dankbar !

PS: Frohe Weihnachten :xmas1:

aber an deinem Code ist (fast) alles falsch...

s1Struct1->Rest=(char*)s2Struct1;

sizeof(_Broadcast)+sizeof(dat)

Diese beiden Zeilen passen überhaupt nicht zueinander!
Beim Empfangen hast du dann denselben Fehler.

Du mußt entweder die 2. Struktur als Unterstruktur der ersten anlegen oder aber die beiden Strukturen einzeln verschicken.

Und warum reservierst du lokale Strukturen mittels new auf dem Heap (hast du vorher Java programmiert?)?

Trotzdem frohe Weihnachten :xmas1:

Danach wird, wenn die 1.Struct gesendet wird, auch die 2.Struct gesendet.
Zusammen haben sie die Größe "sizeof(struct1)+(sizeof(struct2)" .

Auf dem Heap liegen sie, da ohne das die 2.Struct gar nicht empfangen wurde.
Frag aber nicht warum

Serialisiert wird besser, indem du jeder serialisierbarer Klasse eine Funktion serialize/unserialize verpasst.

Verstehe ich nicht.

class Klasse
{
  public:
    void serialize(Stream& stream,int version,uint flags)
    {
      stream.writeInt(v1);
      stream.writeInt(v2);
      stream.writeString(str);
    }

    void unserialize(Stream& stream,int version,uint flags)
    {
      stream.readInt(v1);
      stream.readInt(v2);
      stream.readString(str);
    }

  private:
    int v1,v2;
    std::string str;
};

version und flags sind natürlich optional und können/sollten zusammen in eine Struktur wandern, damit du sie später bei Bedarf erweitern kannst.
Stream ersetzt du durch deine bevorzugte Streamklasse, das können natürlich auch die Standard-C++-Streams sein. writeInt usw. ist dann dementsprechend passend zu ersetzen.
Wie das ganze mit boost geht, steht in der Dokumentation:
http://www.boost.org/doc/libs/1_41_0/libs/serialization/doc/index.html

Deshalb muss der User eine Struktur übergeben können, die dann in eine spezielle Struktur (enthält IP/Hostname/...) gepackt wird, und dann gesendet wird.

Danach wird, wenn die 1.Struct gesendet wird, auch die 2.Struct gesendet.
Zusammen haben sie die Größe "sizeof(struct1)+(sizeof(struct2)" .

Nö, das ist nicht der Fall. Was gesendet wird, ist struct1 (inklusive dem Zeiger Rest, was nie Sinn machen kann) und sizeof(struct2) Bytes, die hinter s1Struct1 liegen. Und das ist bestimmt nicht deine zweite struct. Dass dir das nicht um die Ohren fliegt, ist reine Glückssache.

DarkShadow44 schrieb:

Auf dem Heap liegen sie, da ohne das die 2.Struct gar nicht empfangen wurde.
Frag aber nicht warum

Wenn du ungültige Speicherzugriffe im Programm hast, brauchst du dich über eigenartiges Verhalten nicht wundern. Mach new und delete wieder weg. Müsste sowieso delete[] t heißen.
Außerdem: was ist denn sprintf_s für wüstes Zeug? Hab ich ja noch nie gehört und hat mit C++ auch nicht mehr viel zu tun. Und warum char-Arrays statt std::string? Wieso fopen usw. statt file streams?

Wie würdest du denn eine Struktur übergeben lassen, von der der Inhalt unbekannt ist ? Ich habe sie halt asl "char*" und Länge übergeben.

Ich meine:

InitNetwork(????? dataStrukt,int size)
{
}

sprintf_s schreibt Text in einen buffer.

Und warum char-Arrays statt std::string? Wieso fopen usw. statt file streams?

Ich habe eher mit C angefangen, deshalb verwende ich solche Sachen häufiger

Die Strukturen wurden aber schon korrekt gesendet....
Oder war das nur Zufall und weil Server und Client auf dem selben Rechner liegen ?

Dass zwei direkt nacheinander mit new erzeuge Objekte direkt hintereinander liegen, ist nicht ganz abwegig, aber reiner Zufall.

DarkShadow44 schrieb:

Wie würdest du denn eine Struktur übergeben lassen, von der der Inhalt unbekannt ist ? Ich habe sie halt asl "char*" und Länge übergeben.

Ich meine:

InitNetwork(????? dataStrukt,int size)
{
}

Wie schon gesagt, du hast eine abstrakte Klasse Serializable:

class Serializable
{
  public:
    virtual void serialize(Stream& stream,...)=0;
    virtual void unserialize(Stream& stream,...)=0;
};

... von der alle serialisierbaren Klassen erben.
Irgendeine serialisierbare Klasse kannst du dann also mit InitNetwork(const Serializable& dataStrukt) übergeben. Natürlich kannst du auch einen fertigen Stream oder Buffer übergeben, in dem die gewünschte(n) Struktur(en) schon fertig serialisiert sind.
Um serialize & Co. kommst du nicht herum, da mit char-Casterei grundsätzlich keine Strukturen mit Zeigern (ob direkt oder indirekt durch Container-Objekte wie string und vector) serialisiert werden können. Und ohne Zeiger kommst du nicht mal bis vor die Haustür, geschweige denn irgendwo hin.

struct _data
{
    char name[20];
    int Typ;
    char Message[100];
};

_data data;

void main()
{
    /*.....*/
    InitNetwork(data,sizeof(_data));
    /*.....*/
}

Ist das so nicht machbar ?

Um serialize & Co. kommst du nicht herum, da mit char-Casterei grundsätzlich keine Strukturen mit Zeigern (ob direkt oder indirekt durch Container-Objekte wie string und vector) serialisiert werden können.

Ich habe die Strukturen so schon erfolgreich in Textdateien geschrieben und geladen (Siehe Threadanfang)

Du meinst also, das sinnvollste und einfachste wäre, den User ein Interface "ISerialize" verwenden zu lassen ?
Und den Stream + seine Länge übergeben ?

...
Ist das so nicht machbar ?

Klar ist das machbar... ich weiß aber auch nicht, was du erreichen willst.
Aller Wahrscheinlichkeit nach willst du ja immer denselben Strukturtyp übergeben. Dann nimmt InitNetwork diesen eben als Argument und size brauchst du dann auch nicht mehr.

Ich habe die Strukturen so schon erfolgreich in Textdateien geschrieben und geladen (Siehe Threadanfang)

Wie schon erwähnt, ist das so nicht möglich und war bisher nur Glück. Und du bist ja auch noch gar nicht vor deiner Haustür angelangt
Du kannst ohne Zeiger keine Listen und sonstige Strukturen variabler Größe serialisieren.

Du meinst also, das sinnvollste und einfachste wäre, den User ein Interface "ISerialize" verwenden zu lassen ?

Kommt auf den Fall drauf an... generell ja, wenn du irgendwelche Funktionen hast, die beliebige Strukturen serialisieren können sollen. Sowas hat man aber eher selten.

Und den Stream + seine Länge übergeben ?

Ein Stream kennt seine Länge, die musst du also nicht extra übergeben.

Aller Wahrscheinlichkeit nach willst du ja immer denselben Strukturtyp übergeben.

Ich will eine lib erstellen. Der User soll eine beliebige struct übergeben können, die dann gesendet und empfangen wird.

Du kannst ohne Zeiger keine Listen und sonstige Strukturen variabler Größe serialisieren.

Aber eigentlich sollte das doch "erlaubt" sein:

_data data1;
char*buffer=(char*)&data1;
char*buffer2=new char[sizeof(_data)];
//copy buffer to buffer2
_data*data2=(_data*)buffer2;

Ich bin mir ganz sicher, dass sich Strukturen so verbiegen lassen.
Hat bisher (auch über Netzwerk (!) ) wunderbar geklappt.

Kommt auf den Fall drauf an... generell ja, wenn du irgendwelche Funktionen hast, die beliebige Strukturen serialisieren können sollen. Sowas hat man aber eher selten.

Die soll der User meiner lib ja implementieren

Sorry für die blöde Frage, aber sind Streams char-Pointern nicht sehr ähnlich ?
Wie soll ich denn eine Struct/int/array in einen Stream schreiben ?

Irgendwie finde ich nur I/O - streams zum Lesen/Schreiben auf der Festplatte.

Ich will eine lib erstellen. Der User soll eine beliebige struct übergeben können, die dann gesendet und empfangen wird.

Dann würde ich ein Buffer/Stream übergeben. Ich als Benutzer hätte jedenfalls keine Lust, extra ein paar Strukturen in einer neuen Klasse zu kapseln, wenn ich mehrere davon versenden will.

Aber eigentlich sollte das doch "erlaubt" sein:

_data data1;
char*buffer=(char*)&data1;
char*buffer2=new char[sizeof(_data)];
//copy buffer to buffer2
_data*data2=(_data*)buffer2;

Ich bin mir ganz sicher, dass sich Strukturen so verbiegen lassen.
Hat bisher (auch über Netzwerk (!) ) wunderbar geklappt.

Öh, "erlaubt" ist das, aber das hat nichts mit dem angesprochenen Problem zu tun. Kopiert wird hier allerdings nichts. data2 zeigt jetzt auf uninitialisierten (!) Speicher, der zwar groß genug für ein _data-Objekt ist, aber ein solches wurde dort nicht konstruiert. Falls du mit dem Kommentar meintest, dass hier noch kopiert werden müsste: das geht nur für PODs, in der Regel geht das aber nicht. Insbesondere wenn du Zeiger kopierst, fliegen dir die Destruktoren danach kräftig um die Ohren.

Sorry für die blöde Frage, aber sind Streams char-Pointern nicht sehr ähnlich ?

Nein, Streams abstrahieren das ganze. Ein Stream, der seine Daten im Speicher hält, verwendet intern höchstwahrscheinlich ein Array, aber der Punkt ist, dass der Stream die Daten, die du ihm gibst, auch direkt auf die Festplatte in eine Datei schicken kann oder gleich übers Netzwerk verschicken kann. All das, ohne dass deine Funktionen sich darum kümmern müssen, was der Stream genau macht. Außerdem kümmert er sich automatisch darum, dass immer genug Platz für die Daten vorhanden ist.

Wie soll ich denn eine Struct/int/array in einen Stream schreiben ?

Kommt drauf an... mit den Standardstreams so:

deinStream << deineStruct << deinInt; //erfordert, dass du << für deine Klasse überlädst
//oder:
deineStruct.serialize(deinStream); //erfordert, dass du serialize implementierst
//Arrays gehen natürlich genauso, nur dass du eben jedes Element serialisierst und vorher die Länge in den Stream schreibst.
//Sinnvollerweise kapselt man das irgendwo in einer Klasse oder Streamfunktion.

Mit Boost.Serialize dann & statt <<.
Bei anderen Streanklassen rufst du eben die passenden Funktionen auf. Bei mir z.B. wären das write, writeString etc.

Dann würde ich ein Buffer/Stream übergeben. Ich als Benutzer hätte jedenfalls keine Lust, extra ein paar Strukturen in einer neuen Klasse zu kapseln, wenn ich mehrere davon versenden will.

Ich hätte das in-Stream-Umwandeln dem Benutzer halt gerne abgenommen...
Nochmal, MUSS das dem Benutzer überlassen werden ?

Was sind "PODs" ?

Und wo überlade ich den Operator z.B. für eine struct ?
Und wie geht das bei einer struct ?

Was mache ich dann, wenn ich einen String unbekannter Länge mit einen Stream empfange ?

Wäre halt toll, wenn das Ganze so vereinfacht würde, dass der Benutzer einen char-Pointer auf die struct übergibt und ich die versende(natürlich in MEINER struct ^^.

Was sind "PODs" ?

http://en.wikipedia.org/wiki/Plain_old_data_structures

DarkShadow44 schrieb:

Und wo überlade ich den Operator z.B. für eine struct ?
Und wie geht das bei einer struct ?

http://magazin.c-plusplus.net/artikel/%DCberladung%20von%20Operatoren%20in%20CPlusPlus%20%28Teil%201%29

DarkShadow44 schrieb:

Was mache ich dann, wenn ich einen String unbekannter Länge mit einen Stream empfange ?

Ein String hat eine bekannte Länge.

Aber womit lernst du eigentlich C++? Solche Grundlagen sollten in jedem brauchbaren Anfängerbuch stehen...

Ein String hat nicht immer eine bekannte Länge, ich meine es macht einen Unterschied ob ich einen 120-char oder einen 10-char String sende...

Ein String hat nicht immer eine bekannte Länge, ich meine es macht einen Unterschied ob ich einen 120-char oder einen 10-char String sende...

Unter String versteht man in C++ zunächst zwei Dinge:

• Nullterminiertes char -Array. Die Nullterminierung bestimmt die Länge.
• Instanz von std::string . Die Methode size() gibt über die Länge Auskunft.

Allerdings ist nicht jedes char -Array ein C-String.

Ich speichere die einzelnen Werte jetzt mit '\0' terminiert als Textdatei.
Damit lade ich sie:

ifstream sss;
			sss.open ("c:/delta.txt",ios::in);

			string line;

			if (sss.is_open())
			{
				while (! sss.eof() )
				{
					getline (sss,line);
					cout << line << endl;
				}
				sss.close();
			}

Dadurch bricht die Schleife beim ersten '\0' ab. Wie finde ich den raus, wie lang die Textdatei ist ?
Die Methode "length()" gibt's ja bei "ifstream" nicht, genauso wenig wie "str()" .

Beim senden stellt das kein Problem dar, da die Länge mitgeliefert wird, aber wie finde ich raus die "Position" im Stream raus ?