3. Der sizeof Operator liefert falsche Grösse?

Der sizeof Operator liefert falsche Grösse?

  • I

    Hallo zusammen
    Ich habe hier ein ziemlich merkwürdiges Problem beim Parsen einer 3ds Datei und konnte den Fehler mittlerweile auf einen falschen Rückgabewert des sizeof Operators zurückverfolgen. Ich habe folgende Struktur:

    struct DsTokenHeader{
    uint16 ID;
    uint32 Size;
    };

    Aber sizeof(DsTokenHeader) gibt mir den Wert 8 zurück? 4+2 = 8? 🙄

    Mfg Samuel

    0
  • R

    http://de.wikipedia.org/wiki/Speicherausrichtung
    http://de.wikipedia.org/wiki/Padding

    0
  • D

    Der Compiler darf Strukturen beliebig vergrößern, damit die einzelnen Elemente im Speicher günstiger (soll heißen an z.B. 4 Byte Grenzen) liegen. Das ganze wird padding genannt.

    Du kannst entweder beide Werte einzeln einlesen, dass ist der portabelste Weg.
    Alternativ kannst du den Compiler anweisen, dass er die Struktur packen soll, also die padding bytes weglässt.
    Beim gcc sieht das so aus:

    struct DsTokenHeader{
  uint16 ID;
  uint32 Size;
} __attribute__((packed));

    Beim MSVC müsste es so gehen

    #pragma pack(push, 1)
struct DsTokenHeader{
  uint16 ID;
  uint32 Size;
};
#pragma pack(pop)
    0
  • ?

    Wozu benötigst du denn die Größe? Normalerweise benötigt man die Größe nicht.

    0
  • F

    Sobald es übers Netzwerk etc. geht, brauchst du die Größe um zu sehen ob alle Daten da sind.

    0
  • ?

    Fellhuhn schrieb:

    Sobald es übers Netzwerk etc. geht, brauchst du die Größe um zu sehen ob alle Daten da sind.

    Und genau da macht man was falsch. Man darf niemals direkt in eine Struktur lesen oder aus dieser schreiben. Auch darf man nicht anhand der Struktur-Größe prüfen ob alle Daten angekommen sind.

    0
  • I

    Ojeoje I see, I see...
    Fragt sich, wieso sie beim 3ds Format ein 6Byte Header verwendet haben? Ist das Format so alt, dass es noch aus der 16Bit Ära stammt? Dort hätte es natürlich kein Padding gemacht für 6Bytes...

    0
  • I

    @Janjan

    // obtain the assigned resource reader and open the data source
ResourceReader *pRdr = this->GetReader();
pRdr->Open();

// allocate memory and load the entire data into memory
uint32 szSrc = pRdr->Size();
uint8 *pDta  = new uint8[szSrc];
uint8 *pEnd  = pDta + szSrc;
pRdr->Read(pDta,0,szSrc);

    Weil ich folgenden Code schöner finde

    // throw an exception if the signature inside the *.3ds file is invalid
 DsTokenHeader *pHdr = reinterpret_cast<DsTokenHeader*>(pDta);
 if(pHdr->ID != 0x4d4d) throw DecoderException(FNC,stHdr);
 if(pHdr->Size != szSrc) throw DecoderException(FNC,stHdr);
 pDta += sizeof(DsTokenHeader);

    als diesen hier (leider funktioniert "dank" dem Padding nur dieser hier...)

    // throw an exception if the signature inside the *.3ds file is invalid
 if(*reinterpret_cast<uint16*>(pDta) != 0x4d4d) throw DecoderException(FNC,stHdr);
 if(*reinterpret_cast<uint32*>(pDta+2) != szSrc) throw DecoderException(FNC,stHdr);
 pDta += 6;
    0
  • ?

    Warum sollte man dort unbedingt ein Padding machen? Ist letztendlich im Dateiformat egal. Du liest 6 byte und hast deinen Header. Du musst nur eben die Werte einzeln in deine Struktur kopieren.

    0
  • U

    Ishildur schrieb:

    Ojeoje I see, I see...
    Fragt sich, wieso sie beim 3ds Format ein 6Byte Header verwendet haben? Ist das Format so alt, dass es noch aus der 16Bit Ära stammt? Dort hätte es natürlich kein Padding gemacht für 6Bytes...

    also sollte man immer dafür sorgen, dass eigene structs mind. 64bit groß ist, wenn man modern erscheinen möchte? Oo
    wie schon gesagt wurde, ist dein weg nicht gerade hübsch und die größe völlig belanglos...

    bb

    0
  • ?

    Gerade der zweite sollte nicht funktionieren!!

    Denn da gibst du ja von Hand an, bei welchem Byte dein Integer startet (pDta+2). Also machst du schon vorher irgendwo etwas falsch.

    0
  • R

    Ishildur schrieb:

    Weil ich folgenden Code schöner finde

    // throw an exception if the signature inside the *.3ds file is invalid
 DsTokenHeader *pHdr = reinterpret_cast<DsTokenHeader*>(pDta);
 if(pHdr->ID != 0x4d4d) throw DecoderException(FNC,stHdr);
 if(pHdr->Size != szSrc) throw DecoderException(FNC,stHdr);
 pDta += sizeof(DsTokenHeader);

    Ist vielleicht schöner, hat aber leider ein undefiniertes Resultat. Du gehst hier von einem bestimmten Struktur-Layout aus, das vom Standard nicht garantiert wird und Sache des Compilers ist.

    0
  • I

    @unskilled

    ist dein weg nicht gerade hübsch und die größe völlig belanglos...

    Ok, wie mache ich es hübscher? 🙂

    0
  • ?

    Ishildur schrieb:

    @unskilled

    ist dein weg nicht gerade hübsch und die größe völlig belanglos...

    Ok, wie mache ich es hübscher? 🙂

    Struktur erstellen. 2 Byte in ID laden, 4 byte in Size laden. Nicht 6 byte direkt in die Struktur laden.

    0
  • I

    @Janjan
    Doch genau das zweite funktioniert eben, weil ich dort keine Strukturen verwende, die gepadded werden. Und der pDta Pointer enthält einen Zeiger auf eine Speicheradresse, wo ich vorher das komplette File hineinlese. Und im 3ds File format ist nunmal ein Header: 2 Bytes für die ID und 4 Bytes für die Grösse.

    0
  • I

    @Janjan
    So?

    DsTokenHeader hdr;
memcpy(&hdr,pDta,2);
memcpy(&hdr.Size,pDta+2,4);

// throw an exception if the signature inside the *.3ds file is invalid
if(hdr.ID != 0x4d4d) throw DecoderException(FNC,stHdr);
if(hdr.Size != szSrc) throw DecoderException(FNC,stHdr);
pDta += 6;

    Bleibt vielleicht noch zu erwähnen, dass ich das ziemlich oft an ziemlich vielen verschiedenen Stellen machen muss...

    0
  • ?

    Du programmierst C++, kein C. Also lass das memcpy weg.

    hdr.ID   = *reinterpret_cast<uint16*>(pDta);
hdr.Size = *reinterpret_cast<uint32*>(pDta+2);
    0
  • I

    Aha:

    // first copy the header onto the stack (which is an unnecessary and useless overhead by the way, but ok, we are programming C++ ;-)
 DsTokenHeader hdr;
 hdr.ID   = *reinterpret_cast<uint16*>(pDta);
 hdr.Size = *reinterpret_cast<uint32*>(pDta+2);

 // throw an exception if the signature inside the *.3ds file is invalid
 if(hdr.ID != 0x4d4d) throw DecoderException(FNC,stHdr);
 if(hdr.Size != szSrc) throw DecoderException(FNC,stHdr);
 pDta += 6;

    anstatt:

    // throw an exception if the signature inside the *.3ds file is invalid
 if(*reinterpret_cast<uint16*>(pDta) != 0x4d4d) throw DecoderException(FNC,stHdr);
 if(*reinterpret_cast<uint32*>(pDta+2) != szSrc) throw DecoderException(FNC,stHdr);
 pDta += 6;

    Sag mal, kann es sein, dass du pro Codezeile bezahlt wirst? :p

    0
  • ?

    Code 1 hast du die Daten bereits in deiner Struktur und kannst die Struktur weiterverwenden.

    Code 2 müsstest du die Daten im nachhinein nochmal in die Struktur kopieren um sie zu verwenden.

    0
  • I

    @Janjan
    Hehe nein ist schon klar 😉
    Es ist hier ein wenig speziell, da ich die Daten nur ein einziges Mal benötige, da ich ja jedes Token nur ein einziges Mal auslese. Aber du hast natürlich recht, wenn ich die Daten mehrmals benötige, würde ich es auch so machen wie du. Es ist halt reine Faulheit, dass ich gerne ganze Strukturen kopiere, anstatt da jedes Element einzeln, aber dann muss man halt höllisch aufpassen, dass bei den verwendeten Strukturen kein Padding auftritt. Im Zusammenhang mit der Umstellung auf 64bit werden wohl allerdings so einige Dateiimporter nicht mehr funktionieren. Bspw.

    struct PcmHeader{
 int8  RiffSig[4];
 int32 WaveformChunkSize;
 int8  WaveSig[4];
 int8  FormaSig[4];
 int32 FormatChunkSize;
 int16 FormatTag;
 int16 Channels;
 int32 SampleRate;
 int32 BytesPerSec;
 int16 BlockAlign;
 int16 BitsPerSample;
 int8  DataSig[4];
 int32 DataSize;
};

    Diese Struktur ist 32-bit alignet, es findet IMHO nirgends ein Padding statt. Daher funktioniert ein memcpy problemlos. Bei der Umstellung auf 64bit geht dann leider gar nichts mehr, da heissts dann Member by Member...

    0
Anmelden zum Antworten