Question

我试图将16个无符号值填充到8个字节（64位）中，并使用类似数组的语法访问它们。
＆＃34;数组中的每个条目＆＃34;将是一个半字节 - 4位长。（我计划存储的值绝不大于15）。

我的第一次尝试是：

int main(int argc, char* argv[]) {

    union nibbles_array {
        uint64_t as_long;

        struct inner_array {
            unsigned entry0  : 4;
            unsigned entry1  : 4;
            unsigned entry2  : 4;
            unsigned entry3  : 4;
            unsigned entry4  : 4;
            unsigned entry5  : 4;
            unsigned entry6  : 4;
            unsigned entry7  : 4;
            unsigned entry8  : 4;
            unsigned entry9  : 4;
            unsigned entry10 : 4;
            unsigned entry11 : 4;
            unsigned entry12 : 4;
            unsigned entry13 : 4;
            unsigned entry14 : 4;
            unsigned entry15 : 4;
        } as_array;     
    } array;

    array.as_long = 0x0123456789abcdef;

    printf("%d \n", array.as_array.entry0);
    printf("%d \n", array.as_array.entry1);
    printf("%d \n", array.as_array.entry2);
    printf("%d \n", array.as_array.entry3);
    printf("%d \n", array.as_array.entry4);

    return 0;
}

这个实现产生了两个问题：第一个是值以相反的顺序存储。当然，我可以按相反的顺序分配值以获得所需的结果：array.as_long = 0xfedcba9876543210，但我希望此代码是可移植的，而不是依赖于字节顺序的。第二个是我无法使用索引以类似数组的语法访问半字节。

第二次尝试是这样的：

int main(int argc, char* argv[]) {

    uint64_t pseudo_array = 0x0123456789abcdef;

    #define Array(i) (unsigned)((pseudo_array & (0xfUL << i)) >> i)

    int i;
    for (i = 0; i < 16; ++i) {
        printf("%d ", Array(i));
    }

    printf("\n");

    return 0;
}

以上可以解决第二个问题（类似数组的语法）;现在我可以访问＆＃34;元素＆＃34;使用索引，但是字节序的问题仍然存在，加上这会产生错误的输出：

15 7 11 13 14 15 7 11 13 6 3 9 12 14 15 7

为什么以上产生此输出？
请您建议实施，这将允许我访问＆＃34;阵列＆＃34;通过索引和将解决字节序问题？

Answer 1

您的第一次尝试肯定存在可移植性问题：位域与内存中的实际位之间的映射未在标准中定义。它不完全是一个字节序问题，你也不能拥有类似语法的数组。

您的第二次尝试更便携。问题不是字节序，而是你自己对数组的第n个元素的概念。宏是错误的，因为你没有移动正确的位数：i必须乘以4.我建议这个宏符合你的理解：

#define Array(a, i)  ((unsigned)(((a) >> (60 - 4 * (i))) & 0xf))

Answer 2

不希望的输出是由宏以错误的方式定义的事实引起的;你的意思是转移 nibble-wise ，而不是 bit-wise 。通过如下定义宏可以实现所需的行为。

#define Array(i) (unsigned)((pseudo_array & ((uint64_t)0x0f << (4*i))) >> (4*i))

Answer 3

而不是存储＆＃34;向量＆＃34;作为位域，可以使用动态分配的数组，以及一组用于访问单个＆＃34;索引的函数。您的数组以及设置或获取＆＃34;数组的更大部分的功能＆＃34;使用较大的类型（例如uint64_t）。

类似以下API

// The "na" prefix stands for Nibble Array

struct nibble_array
{
    uint8_t *data;  // The actual "array" of nibbles
    size_t   size;  // Current size of "array" (number of elements)
};

// Create an array containing a number of elements
struct nibble_array *na_create(const size_t elements);

// Get a value from specified index in array
int na_get(const struct nibble_array *array, const size_t index);

// Set a specified index in the array to a value
void na_set(struct nibble_aray *array, const size_t index, const int value);

// Get the number of elements (nibbles) in the array
size_t na_size(const struct nibble_array *array);

// Set a larger part of the array to some values
void na_set64(struct nibble_array *array, size_t start_index, const uint64_t value);

如果您希望数据是私有的，请不要提供nibble_array结构的定义（请阅读opaque pointers）。

Answer 4

这样的事情怎么样：

#include <stdio>

int main(int argc, char* argv[]) {

    unsigned char array[8] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF };

    #define Array(i) (i%2 ? (array[i/2] & 0x0F) : ((array[i/2] & 0xF0) >> 4))

    int i;
    for (i = 0; i < 16; ++i) {
        printf("%d ", Array(i));
    }

    printf("\n");
    return 0;
}

Answer 5

我相信@chqrlie关于字节序问题是正确的，但我认为使用数组会更容易。

uint8_t ary[20]; /* 40 nibbles */
#define getnibblelen(ary) (sizeof(ary) * 2) /* works because it's an ARRAY of uint8_t, wouldn't work if you're passing the array to a function. */
#define getnibble(ary, idx) (idx % 2 ? /* if odd */ ary[idx/2] & 0xf0 >> 4 : /* if even */ ary[idx/2] & 0x0f)
#define setnibble(ary, idx, val) (idx % 2 ? ary[idx/2] = (ary[idx/2] & 0x0f) | ((val & 0x0f) << 4) : ary[idx/2] = (ary[idx/2] & 0xf0) | (val & 0x0f))

C：实现半字节数组

5 个答案: