So fügen Sie N -Bytes im 64 -Bit -System hinzu

Question

Ich arbeite in 64 Bit x_86 64 -Bit -OSX -System.

Ich lese die Datei der Legacy -Datenbank. Es wird in einen Speicherblock geladen und unter Verwendung von Offsets in den Strukturen gelesen. Es ist im 32 -Bit -Modus geschrieben.

Um im 64 -Bit -Modus richtig zu lesen, möchte ich der Basisadresse einer Struktur n Bytes hinzufügen.

Seit Zeiger Incement

Inkrement hilft mir nicht, es zu tun, da es im 64 -Bit -Modus ist, dass jeder Zeiger B -Byte lang ist.

Grüße, Dhana.

Ich habe hier einen Code gepostet. Ich denke, es ist richtig ..

   struct CamNodeTag { 
          CamNodeTag  *nextCam; // next cam
          SInt32 numMake; 
          char  *menuMake; 
    }; 

    long pBaseAddr; // this is long so we an offset bytes from it.

    //Get the size of of the structure in 32 bit environment.//in 64 bit envi it is 20 bytes.
    int CamNodeTagSizeIn32BitMode = 12;


    //Do it in a while loop..
 int i=0;
 CamNodeTag * pNode = (CamNodeTag *)(pBaseAddr + i*CamNodeTagSizeIn32BitMode);

while(pNode !=NULL)
{
    //Do the cam stuff here..

// to get the next node, we add the base addr to the offset


//This will give next cam
 i++;
   pNode = (CamNodeTag *)(pBaseAddr + i*CamNodeTagSizeIn32BitMode);

}

Answer 1

ich stattdessen empfehlen dass Sie die Datei von der Festplatte mithilfe von Funktionen lesen, die Sie schreiben, z. B. read_uint32_whatever_endian(FILE*) und so und lagern Sie diese in Ihrem neuen 64-Bit-In-Memory structs.

Dies isoliert Ihren neuen Code aus den Auswahlmöglichkeiten, die der Compiler über das Speicherlayout Ihrer Strukturen trifft.

Auf einer modernen Maschine sind die Leistungskosten für solche Parsen so minimal, dass ich sicher bin, dass Sie es kaum messen können.

Während es eine gibt leicht Eckschicht wo nmapEd große Datenbankdateien, die dieselbe binäre Struktur wie die In-Memory-Darstellung des Compiler speichern, ist ein Plus. Dieser Fall ist in der Praxis nicht viel wert.

Die Vorteile einer anderen Serialisierung auf der Festplatte im Gedächtnis bieten zahlreiche praktische Plus:

• Es ist tragbar - Sie können Ihren Code auf verschiedenen Prozessoren mit unterschiedlichen Wortgrößen und unterschiedlichen Endianern ohne Probleme ausführen
• Sie können die Strukturen jederzeit erweitern - Sie können die In -Memory -Strukturen zu Objekten mit Methoden und so, sogar virtuellen C ++ - Methoden und anderen Vorteilen des objektorientierten Designs machen. Sie können auch Mitglieder hinzufügen, die nicht serialisiert werden, z. B. Zeiger und andere Felder, und Sie können neue Datenbankdateiversionen problemlos unterstützen

Answer 2

Um einen Zeiger durch etwas anderes als seine einheimische Größe voranzutreiben, müssen Sie zu char *werfen.

Um aus einer Datei zu lesen, die 32 Bitwerte als "Zeiger" mit einem 64 -Bit -Prozessor verwendet, müssen Sie Ihre Strukturen neu definieren, damit Felder, die früher Zeiger waren, noch 32 Bit sind.

typedef int Off32; // our "pointers" need to be 32 bit ints rather than pointers.

struct CamNodeTag { 
   Off32  nextCam; // next cam
   SInt32 numMake; 
   Off32  menuMake; 
}; 

char * pBaseAddr; // this is char * so we an offset bytes from it.

// set this to point to the first node.
CamNodeTag * pNode = (CamNodeTag *)(pBaseAddr + first_node_offset);

// to get the next node, we add the base addr to the offset
// in the structure.

pNode = (CamNodeTag *)(pBaseAddr + pNode->nextCam);

// assuming that the menuMake pointer is also an offset from the base
// use this code to get the actual pointer.
//
char * pMenu = (pBaseAddr + pNode->menuMake);