Ich arbeite seit geraumer Zeit schon an diesem problem und bin mir nicht sicher, ob ich den Grund fuer mein "Versagen" endlich gefunden habe. Also wollte ich mal die Allgemeinheit fragen (die sicherlich mehr weiss als ich).

Ich schreib das mal etwas grundlegender als in meinem Programm, damit das Einlesen nich ewig dauert:

Mein struct:

struct MyStruct
{
  float a;
  long b;
  long c;
  char d[20];
  char e[20];
  float f;
}

Meine template-class:

template <class A>
class MyClass
{
private:
  A* MyStructInClass; //class A ist das struct von oben

public:
  void InitFromBuffer(char* Buffer);
}

Ich bekomme jetzt einen char-pointer mit der Byte-Laenge der struct in dem die Daten liegen, die ich benoetige und will diese in MyStructInClass speichern:

void MyClass<MyStruct>::InitFromBuffer(char* Buffer)
{
  memcpy(this->MyStructInClass, Buffer, sizeof(MyStruct));
}

Das klappt nicht (Fehler wegen korruptem Speicher). Liegt nach meiner Ansicht daran, dass ich versuche den Speicher eines members zu ueberschreiben.

Meine Alternative:

void MyClass<MyStruct>::InitFromBuffer(char* Buffer)
{
  this->MyStructInClass = reinterpret_cast<MyStruct*>(Buffer);
}

Das klappt zwar ohne Runtime-Error, aber es steht meistens nich das gewuenschte in MyStructInClass:

a, b und c haben noch die korrekten Werte. Aber ab dem Array d stimmen die Werte nicht mehr.

Meine Begruendung:
C++ (bzw. .NET) verarbeitet char[20] als char*, d.h. man kann einen char[20] sowohl mit einem char* der Laenge 5 fuellen, als auch der Laenge 50. Zur Laufzeit wird der Speicher dynamisch angepasst.
Fuelle ich char d[20] mit "aaa", hat d die Groesse 3 Byte, bei "12345678901234567890123" die Groesse 23 Byte.
Prinzipiell macht das meine Metjode damit wohl nicht-implementierbar

void MyClass<MyStruct>::InitFromBuffer(char* Buffer)
{
  MyStructInClass = malloc(sizeof(MyStruct));
  memcpy(this->MyStructInClass, Buffer, sizeof(MyStruct));
}

(btw, wozu brauchst du eigentlich an der Stelle Templates?)

Nein, d ist immer 20 Bytes lang. Wenn Du nur 3 Bytes hineinschreibst, sind eben 17 Bytes "leer" (es steht das drin was vor dem kopieren auch drin stand - meistens Speichermüll), wenn Du 23 Bytes hineinschreibst, überschreibst Du die ersten drei Bytes von e.

Durch das template koennten diese (halbwegs) dynamisch genutzt werden, und erspart damit eine Menge Arbeit weil man nicht antausenden Stellen alles neu implementieren muss.

void MyClass<MyStruct>::InitFromBuffer(char* Buffer)
{
  MyStructInClass = (MyStruct*)malloc(sizeof(MyStruct));
  memcpy(this->MyStructInClass, Buffer, sizeof(MyStruct));
}

Bin aber noch net sicher, ob das laeuft, werds aber dann hier schreiben sobald ichs getestet habe.

@LordJaxom:
Die "abenteuerlichen" Vermutungen kommen immer dann, wenn man keinen Grund fuer Fehler findet

War bisher ja auch deiner Meinung, aber das hier liess mich zweifeln.

Die uebrigen Fehler liegen nich an mir