我有65个不同位长的参数，我需要填写一个八位字符串。参数将以八位字节串连续填充。例如，假设第一个参数是1位长，那么它将填充在八位字节串的第1个八位字节的第0位。现在第二个参数假设为9位长。因此，该参数的前7位将填充在相同的八位位组中，接下来的2位应该位于下一个八位位组的第0位和第1位位置。类似地，其他参数将填充在八位字节串中。我试着编写一个函数，在这里我传递指向当前八位字节的指针，位位置和数据将被复制的源指针。但我发现逻辑实现有困难。我尝试了很多逻辑（位操作，位移，旋转等）但无法得到正确的逻辑。如果有人能在“C”中给我一个逻辑/功能，我将不胜感激。您也可以使用不同的功能原型。
我已经编写了16位代码，如下所示：
void set16BitVal(U8** p_buf, U8* bitPos, U16 src)
{
U16 ctr;
U16 bitVal;
U16 srcBitVal;
U16 tempSrc = src;
U8 temp = **p_buf;
printf("\n temp = %d\n", temp);
for(ctr=0; ctr<16; ctr++)
{
bitVal = 1;
bitVal = bitVal << ctr;
srcBitVal = src & bitVal;
temp = temp | srcBitVal;
**p_buf = temp;
if(srcBitVal)
srcBitVal = 1;
else
srcBitVal = 0;
printf("\n bit = %d, p_buf = %x \t p_buf=%d bitPos=%d ctr=%d srcBitVal = %d\n",\
tempSrc, *p_buf, **p_buf, *bitPos, ctr, srcBitVal);
*bitPos = (*bitPos+1)%8; /*wrap around after bitPos:7 */
if(0 == *bitPos)
{
(*p_buf)++; /*jump to next octet*/
temp = **p_buf;
printf("\n Value of temp = %d\n", temp);
}
//printf("\n ctr=%d srcBitVal = %d", ctr, srcBitVal);
printf("\n");
}
}
但问题是假设我传递src = 54647，我得到以下输出：
temp = 0
bit = 54647，p_buf = bf84da4b p_buf = 1 bitPos = 0 ctr = 0 srcBitVal = 1
bit = 54647，p_buf = bf84da4b p_buf = 3 bitPos = 1 ctr = 1 srcBitVal = 1
bit = 54647，p_buf = bf84da4b p_buf = 7 bitPos = 2 ctr = 2 srcBitVal = 1
bit = 54647，p_buf = bf84da4b p_buf = 7 bitPos = 3 ctr = 3 srcBitVal = 0
bit = 54647，p_buf = bf84da4b p_buf = 23 bitPos = 4 ctr = 4 srcBitVal = 1
位= 54647，p_buf = bf84da4b p_buf = 55 bitPos = 5 ctr = 5 srcBitVal = 1
bit = 54647，p_buf = bf84da4b p_buf = 119 bitPos = 6 ctr = 6 srcBitVal = 1
位= 54647，p_buf = bf84da4b p_buf = 119 bitPos = 7 ctr = 7 srcBitVal = 0
temp = 0的值
bit = 54647，p_buf = bf84da4c p_buf = 0 bitPos = 0 ctr = 8 srcBitVal = 1
bit = 54647，p_buf = bf84da4c p_buf = 0 bitPos = 1 ctr = 9 srcBitVal = 0
bit = 54647，p_buf = bf84da4c p_buf = 0 bitPos = 2 ctr = 10 srcBitVal = 1
bit = 54647，p_buf = bf84da4c p_buf = 0 bitPos = 3 ctr = 11 srcBitVal = 0
bit = 54647，p_buf = bf84da4c p_buf = 0 bitPos = 4 ctr = 12 srcBitVal = 1
位= 54647，p_buf = bf84da4c p_buf = 0 bitPos = 5 ctr = 13 srcBitVal = 0
bit = 54647，p_buf = bf84da4c p_buf = 0 bitPos = 6 ctr = 14 srcBitVal = 1
位= 54647，p_buf = bf84da4c p_buf = 0 bitPos = 7 ctr = 15 srcBitVal = 1
temp = 0的值
然而，预期的输出是：下一个字节应该从src的第8位开始填充值。
有人可以帮我解决一下吗？
答案 0 :(得分：1)
你很幸运。因为我喜欢有点蠢蠢欲动，所以我为你编写了BitBuffer的通用实现。我没有彻底测试过（例如并非所有讨厌的角落情况），但正如您将看到的，它通过了我在下面的代码中添加的简单测试。
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
struct BitBuffer {
unsigned length; // No of bits used in buffer
unsigned capacity; // No of bits available in buffer
uint8_t buffer[];
};
struct BitBuffer * newBitBuffer (
unsigned capacityInBits
) {
int capacityInBytes;
struct BitBuffer * result;
capacityInBytes = (capacityInBits / 8);
if (capacityInBits % 8 != 0) {
capacityInBytes++;
}
result = malloc(sizeof(*result) + capacityInBytes);
if (result) {
result->length = 0;
result->capacity = capacityInBits;
}
return result;
}
bool addBitsToBuffer (
struct BitBuffer * bbuffer, const void * bits, unsigned bitCount
) {
unsigned tmpBuf;
unsigned tmpBufLen;
unsigned tmpBufMask;
uint8_t * nextBufBytePtr;
const uint8_t * nextBitsBytePtr;
// Verify input parameters are sane
if (!bbuffer || !bits) {
// Evil!
return false;
}
if (bitCount == 0) {
// No data to add? Nothing to do.
return true;
}
// Verify we have enough space available
if (bbuffer->length + bitCount > bbuffer->capacity) {
// Won't fit!
return false;
}
// Get the first byte we start writing bits to
nextBufBytePtr = bbuffer->buffer + (bbuffer->length / 8);
// Shortcut:
// If we happen to be at a byte boundary,
// we can simply use memcpy and save us a lot of headache.
if (bbuffer->length % 8 == 0) {
unsigned byteCount;
byteCount = bitCount / 8;
if (bitCount % 8 != 0) {
byteCount++;
}
memcpy(nextBufBytePtr, bits, byteCount);
bbuffer->length += bitCount;
return true;
}
// Let the bit twiddling begin
nextBitsBytePtr = bits;
tmpBuf = *nextBufBytePtr;
tmpBufLen = bbuffer->length % 8;
tmpBuf >>= 8 - tmpBufLen;
tmpBufMask = (~0u) >> ((sizeof(unsigned) * 8) - tmpBufLen);
// tmpBufMask has the first tmpBufLen bits set to 1.
// E.g. "tmpBufLen == 3" ==> "tmpBufMask == 0b111 (7)"
// or "tmpBufLen == 6" ==> "tmpBufMask = 0b111111 (63)", and so on.
// Beyond this point we will neither access bbuffer->length again, nor
// can this function fail anymore, so we set the final length already.
bbuffer->length += bitCount;
// Process input bits in byte chunks as long as possible
while (bitCount >= 8) {
// Add 8 bits to tmpBuf
tmpBuf = (tmpBuf << 8) | *nextBitsBytePtr;
// tmpBuf now has "8 + tmpBufLen" bits set
// Add the highest 8 bits of tmpBuf to our BitBuffer
*nextBufBytePtr = (uint8_t)(tmpBuf >> tmpBufLen);
// Cut off the highest 8 bits of tmpBuf
tmpBuf &= tmpBufMask;
// tmpBuf now has tmpBufLen bits set again
// Skip to next input/output byte
bitCount -= 8;
nextBufBytePtr++;
nextBitsBytePtr++;
}
// Test if we still have bits left. That will be the case
// if the input bit count was no integral multiple of 8.
if (bitCount != 0) {
// Add bitCount bits to tmpBuf
tmpBuf = (tmpBuf << bitCount) | (*nextBitsBytePtr >> (8 - bitCount));
tmpBufLen += bitCount;
}
// tmpBufLen is never 0 here, it must have a value in the range [1, 14].
// We add zero bits to it so that tmpBuf has 16 bits set.
tmpBuf <<= (16 - tmpBufLen);
// Now we only need to add one or two more bytes from tmpBuf to our
// BitBuffer, depending on its length prior to adding the zero bits.
*nextBufBytePtr = (uint8_t)(tmpBuf >> 8);
if (tmpBufLen > 8) {
*(++nextBufBytePtr) = (uint8_t)(tmpBuf & 0xFF);
}
return true;
}
int main ()
{
bool res;
uint8_t testData[4];
struct BitBuffer * buf;
buf = newBitBuffer(1024); // Can hold up to 1024 bits
assert(buf);
// Let's add some test data.
// Add 1 bit "1" => Buffer "1"
testData[0] = 0xFF;
res = addBitsToBuffer(buf, testData, 1);
assert(res);
// Add 6 bits "0101 01" => Buffer "1010 101"
testData[0] = 0x54;
res = addBitsToBuffer(buf, testData, 6);
assert(res);
// Add 4 Bits "1100" => Buffer "1010 1011 100"
testData[0] = 0xC0;
res = addBitsToBuffer(buf, testData, 4);
assert(res);
// Add 16 Bits "0111 1010 0011 0110"
// ==> Buffer "1010 1011 1000 1111 0100 0110 110
testData[0] = 0x7A;
testData[1] = 0x36;
res = addBitsToBuffer(buf, testData, 16);
assert(res);
// Add 5 Bits "0001 1"
// ==> Buffer "1010 1011 1000 1111 0100 0110 1100 0011"
testData[0] = 0x18;
res = addBitsToBuffer(buf, testData, 5);
assert(res);
// Buffer should now have exactly a length of 32 bits
assert(buf->length == 32);
// And it should have the value 0xAB8F46C3
testData[0] = 0xAB;
testData[1] = 0x8F;
testData[2] = 0x46;
testData[3] = 0xC3;
assert(memcmp(buf->buffer, testData, 4) == 0);
free(buf);
return 0;
}
代码没有针对最大性能进行优化，但我认为它应该具有不错的性能。任何额外的性能调整都会显着增加代码大小，我希望保持代码相当简单。有些人可能会争辩说使用>> 3代替/ 8和& 0x7而不是% 8会带来更好的性能，但如果使用体面的C编译器，那就是如果启用优化，编译器将在内部执行，因此我更倾向于保持代码更具可读性。
附加说明
将指针传递给多字节数据类型时，请查看字节顺序！例如。以下代码
uint16_t x16 = ...;
addBitsToBuffer(buf, &x16, ...);
uint32_t x32 = ...;
addBitsToBuffer(buf, &x32, ...);
在大端机器（PPC CPU）上工作正常，但它可能无法在小端机器（例如x86 CPU）上提供预期的结果。在小端机器上，您必须先交换字节顺序。您可以将htons和htonl用于此目的：
uint16_t x16 = ...;
uint16_t x16be = htons(x16);
addBitsToBuffer(buf, &x16be, ...);
uint32_t x32 = ...;
uint32_t x32be = htonl(x32);
addBitsToBuffer(buf, &x32be, ...);
在大端机器上，htonX函数/宏通常什么也不做，因为该值已经是“网络字节顺序”（大端序），而在小端机器上它们将交换字节顺序。
传递uint8_t指针将始终在任一机器上工作，它只是一个字节，因此没有字节顺序。