Como adicionar n bytes no sistema de 64 bits

Question

Estou trabalhando no sistema OSX de 64 bits X_86 de 64 bits.

Estou lendo o arquivo do banco de dados Legacy. Ele é carregado em um bloco de memória e usando compensações que lê para as estruturas. Está escrito no modo de 32 bits.

Portanto, para ler corretamente no modo de 64 bits, quero adicionar n bytes ao endereço base de uma estrutura.

Desde o incidente do ponteiro

O incremento não me ajuda a fazê -lo como está no modo de 64 bits, cada ponteiro é B byte de comprimento.

Atenciosamente, Dhana.

Eu publiquei algum código aqui. Eu acho que está certo ..

   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

EU recomendo que você leu o arquivo do disco usando funções que você escreve como read_uint32_whatever_endian(FILE*) e tal, e armazene-os em seu novo 64 bits na memória structs.

Isso isola seu novo código das opções que o compilador faz sobre o layout de memória de suas estruturas.

Em uma máquina moderna, o custo de desempenho dessa análise é tão mínimo que tenho certeza de que você dificilmente pode medi -lo.

Enquanto há um pouco Caso de canto onde nmapOs arquivos de banco de dados grandes que armazenam a mesma estrutura binária que a representação na memória do compilador é uma vantagem, este caso não vale muito na prática.

Os benefícios de uma serialização diferente no disco para a memória fornecem muitas vantagens práticas:

• É portátil - você pode executar seu código em diferentes processadores com diferentes size de palavras e diferentes endianos sem problemas
• Você pode estender as estruturas a qualquer momento - você pode transformar as estruturas na memória em objetos com métodos e até métodos virtuais de C ++ e outros benefícios do design orientado a objetos; Você também pode adicionar membros que não são serializados, como ponteiros e outros campos, e você pode suportar novas versões de arquivo de banco de dados facilmente

Answer 2

Para avançar um ponteiro por algo que não seja o seu tamanho nativo, você deve ser lançado para char *.

Para ler em um arquivo que usa valores de 32 bits como "ponteiros" usando um processador de 64 bits, você deve redefinir suas estruturas para que os campos que costumavam ser ponteiros ainda tenham 32 bits de tamanho.

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