Cómo agregar n bytes en el sistema de 64 bits

Question

Estoy trabajando en un sistema OSX X_86 de 64 bits de 64 bits.

Estoy leyendo el archivo de la base de datos Legacy. Se carga en un bloque de memoria y usa compensaciones que lee a las estructuras. Está escrito en modo de 32 bits.

Entonces, para leer correctamente en modo de 64 bits, quiero agregar n bytes a la dirección base de una estructura.

Desde la incencia del puntero

El incremento no me ayuda a hacerlo, ya que está en modo de 64 bits, cada puntero tiene un byte de largo.

Saludos, Dhana.

He publicado algún código aquí. Supongo que es correcto ..

   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

yo recomendar en su lugar que lee el archivo del disco utilizando funciones que escribe, como read_uint32_whatever_endian(FILE*) y tal, y guárdalos en su nuevo 64 bits in-Memory structs.

Esto aísla su nuevo código de las elecciones que el compilador hace sobre el diseño de memoria de sus estructuras.

En una máquina moderna, el costo de rendimiento de tal análisis es tan mínimo que estoy seguro de que apenas puedes medirlo.

Mientras que hay un leve caso de esquina donde nmapED grandes archivos de base de datos que almacenan la misma estructura binaria que la representación en memoria del compilador es una ventaja, este caso no vale mucho en la práctica.

Los beneficios de una serialización diferente en el disco en la memoria proporcionan muchas ventajas prácticas:

• Es portátil: puede ejecutar su código en diferentes procesadores con diferentes tallas de palabras y diferentes endians sin problemas
• Puede extender las estructuras en cualquier momento: puede convertir las estructuras en memoria en objetos con métodos y tales métodos virtuales de C ++ y otros beneficios del diseño orientado a objetos; También puede agregar miembros que no se serializan, como punteros y otros campos, y puede admitir nuevas versiones de archivos de base de datos fácilmente

Answer 2

Para avanzar un puntero por algo más que su tamaño nativo, debe lanzar a Char *.

Para leer de un archivo que utiliza valores de 32 bits como "punteros" utilizando un procesador de 64 bits, debe redefinir sus estructuras para que los campos que solían ser punteros sigan siendo de 32 bits de tamaño.

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);