使用C / C ++解析二进制文件

Question

I am currently dealing with some binary files and the data format is specified in some file. The way I am using is define some corresponding struct to read in data one by one from the buffer. For example, if I know in the beginning of the file, there is a packet header specifying the following data type and data length in this packet, I will first parse this packet header.

  #pragma pack (1)
  struct PacketHeader
  {
     uint16_t PacketSize;
     uint16_t PacketType;
  };
  char *buffer = new char[size];
  file.read(buffer, size);
  //read in the PacketHeader
  PacketHeader ph;
  ph = *(PacketHeader *)buffer;
  //switch data type
  switch(ph.PacketType)
  {
     //do something
  }

So far, everything goes well, but problems occur when I donot use the struct method. For example, I know that at some position of the buffer following datatype A , there will be some information about the underlying composition of A , say one uint32_t variable and the other uint32_t variable. The number of such variable pairs is specified in A , and as there are just two variables in this pair, I tried to just parse them directly without any structs, eg,

  //get pair_num from previous parsed data
  for(int i = 0; i < pair_num; i++)
  {
      std::cout << (uint32_t)(buffer + 2 * i * sizeof(uint32_t))
                << (uint32_t)(buffer + (2 * i + 1) * sizeof(uint32_t))
                << std::endl;
  }

However, the above code does not work. The two variables parsed from the files are wrong. So I turned back to the structure method and managed to get the correct result with the following codes:

 struct B
 {
    uint32_t v1;
    uint32_t v2;
 }
 B b;
 //get pair_num from previous parsed data
 for(int i = 0; i < pair_num; i++)
 {
     b = *(B *)(buffer + i * 8);
     std::cout << b.v1
               << b.v2
               << std::endl;
 }

I am just wondering what is the difference between these two methods? Anyone could give me some insights?

Answer 1

Instead of converting char * to uint32_t * and dereferencing it you converting char * pointer to uint32_t so printing address on std::cout (or part of address on 64bit machine), correct way should be this:

  for(int i = 0; i < pair_num; i++)
  {
      std::cout << *((uint32_t *)(buffer + 2 * i * sizeof(uint32_t)))
                << *((uint32_t *)(buffer + (2 * i + 1) * sizeof(uint32_t)))
                << std::endl;
  }

but way simpler would be to use proper pointer:

  uint32_t *ptr = (uint32_t *) buffer;
  for(int i = 0; i < pair_num; i++)
  {
      std::cout << *(ptr + 2 * i )
                << *(ptr + 2 * i + 1 )
                << std::endl;
  }

or even:

  uint32_t *ptr = (uint32_t *) buffer;
  for(int i = 0; i < pair_num; i++)
  {
      std::cout << ptr[2 * i]
                << ptr[2 * i + 1]
                << std::endl;
  }

Note that on the second way (as well as using header as struct) you are doing unnecessary copy, I think what you wanted is this instead:

struct B
 {
    uint32_t v1;
    uint32_t v2;
 }
 //get pair_num from previous parsed data
 for(int i = 0; i < pair_num; i++)
 {
     B *b = (B *)(buffer + i * 8);
     std::cout << b->v1
               << b->v2
               << std::endl;
 }

unless you intentionally copy that structure for whatever reason.