使用指针在结构中的元素之间移动

Question

这与this question密切相关。

我正在使用libusb 编写一些 USB 代码。查看库的源代码，我看到他们正在使用指针来解析数据并填充structs。

例子：

来自libusb.h：

struct libusb_endpoint_descriptor {
    uint8_t  bLength;
    uint8_t  bDescriptorType;
    uint8_t  bEndpointAddress;
    uint8_t  bmAttributes;
    uint16_t wMaxPacketSize;
    uint8_t  bInterval;
    uint8_t  bRefresh;
    uint8_t  bSynchAddress;
    const unsigned char *extra;
    int extra_length;
};

来自descriptor.c：

struct libusb_endpoint_descriptor *endpoint
unsigned char *buffer
int host_endian

usbi_parse_descriptor(buffer, "bbbbwbbb", endpoint, host_endian);

usbi_parse_descriptor 在哪里：

int usbi_parse_descriptor(
        unsigned char *source, 
        const char *descriptor,
        void *dest, 
        int host_endian)
{
    unsigned char *sp = source;
    unsigned char *dp = dest;
    uint16_t w;
    const char *cp;

    for (cp = descriptor; *cp; cp++) {
        switch (*cp) {
        case 'b':    /* 8-bit byte */
                *dp++ = *sp++;
                break;
        case 'w':    /* 16-bit word, convert from little endian to CPU */
            dp += ((uintptr_t)dp & 1);    /* Align to word boundary */
            if (host_endian) {
                memcpy(dp, sp, 2);
            } else {
                w = (sp[1] << 8) | sp[0];
                *((uint16_t *)dp) = w;
            }
            sp += 2;
            dp += 2;
            break;
        }
    }

    return (int) (sp - source);
}

---

我的问题是使用char指针来遍历缓冲区。

1. uint8_t 被编译器对齐为例如uint32_t 整数——因此*dp++ 以错误的地址结束，这难道不是一种风险吗？
   错误地址是指dp指向的struct libusb_endpoint_descriptor中变量的地址：

   unsigned char *buffer = REPLY from request to USB device.
   struct libusb_endpoint_descriptor *endpoint;
   unsigned char *dp = (void*) endpoint;
   
     *dp = buffer[0] ==> struct libusb_endpoint_descriptor -> bLength
   *++dp = buffer[1] ==> struct libusb_endpoint_descriptor -> bDescriptorType
   ... v                                                         ^
       |                                                         |
       +--- does this guaranteed align with this ----------------+
   

2. 这会发生什么？：

   dp += ((uintptr_t)dp & 1);    /* Align to word boundary */
   

如果内存中的结构是这样的：

ADDRESS  TYPE      NAME
0x000a0  uint8_t   var1
0x000a1  uint16_t  var2
0x000a3  uint8_t   var3

和dp 指向var1； 0x000a0，上面的语句会做什么？

Answer 1

关于第二个问题，地址只是一个整数，只是编译器使用它来表示内存位置。 ((uintptr_t)dp & 1) 表达式首先将其转换为正确的整数（uintptr_t 类型是一个大到足以容纳指针的整数），然后检查是否设置了最低有效位。如果未设置该位，则表达式的结果为零，这意味着地址是偶数且 16 位对齐。如果设置了 位，则意味着地址是不均匀的并且不是 16 位对齐的。

这个表达式的有趣之处在于它会导致0 或1 成为结果，具体取决于该位是否未设置。如果未设置该位，则将0 添加到已经 16 位对齐的地址中，不会发生任何变化。另一方面，如果地址不是 16 位对齐的，则表达式会导致将 1 添加到地址中，自动将其与 16 位边界对齐。

Answer 2

1. 不确定，我不会打赌保证它的标准，但至少在大多数 PC 平台上它应该可以工作。
2. dp += ((uintptr_t)dp & 1); 将 dp 舍入到下一个 2 的倍数。如果 dp 已经是偶数，则该语句无效。

Answer 3

为了解决您的第一个问题，dest 指向一些要写入的内存。 void * 告诉你没有声明特定的类型，它只是一块内存。 switch 块测试预期的内容，并将指针增加一个或两个字节。这样做的方式是安全的，因为unsigned char 保证与sizeof(char) 对齐，即1。

编辑：不安全的是，在这种情况下dest 指向libusb_endpoint_descriptor，其对齐假设在descriptor 中表示。这些假设取决于无法保证的填充期望。可能这里的代码依赖于编译器选项进行打包。