Во-первых, используйте strtoul, чтобы получить 32-разрядное значение.Затем преобразуйте порядок байтов в big-endian с помощью htonl.Наконец, сохраните результат в вашем массиве:
#include <arpa/inet.h>
#include <stdlib.h>
/* ... */
unsigned char q[32] = "1100111...";
unsigned char result[4] = {0};
*(unsigned long*)result = htonl(strtoul(q, NULL, 2));
Есть и другие способы.
Но мне не хватает <arpa/inet.h>!
Тогда вам нужно знать, чтопорядок байтов вашей платформы.Если это прямой порядок байтов, то htonl ничего не делает и может быть опущен.Если это младший порядок, то htonl это просто:
unsigned long htonl(unsigned long x)
{
x = (x & 0xFF00FF00) >> 8) | (x & 0x00FF00FF) << 8);
x = (x & 0xFFFF0000) >> 16) | (x & 0x0000FFFF) << 16);
return x;
}
Если вам повезет, ваш оптимизатор может увидеть, что вы делаете, и превратить его в эффективный код.Если нет, то, по крайней мере, все это реализуемо в регистрах и O (log N).
Если вы не знаете, каков порядок байтов в вашей платформе, то вам нужно его обнаружить:
typedef union {
char c[sizeof(int) / sizeof(char)];
int i;
} OrderTest;
unsigned long htonl(unsigned long x)
{
OrderTest test;
test.i = 1;
if(!test.c[0])
return x;
x = (x & 0xFF00FF00) >> 8) | (x & 0x00FF00FF) << 8);
x = (x & 0xFFFF0000) >> 16) | (x & 0x0000FFFF) << 16);
return x;
}
Может быть long равен 8 байтам!
Что ж, OP подразумевает 4-байтовые входы с размером их массива, но 8-байтовый long выполним:
#define kCharsPerLong (sizeof(long) / sizeof(char))
unsigned char q[8 * kCharsPerLong] = "1100111...";
unsigned char result[kCharsPerLong] = {0};
*(unsigned long*)result = htonl(strtoul(q, NULL, 2));
unsigned long htonl(unsigned long x)
{
#if kCharsPerLong == 4
x = (x & 0xFF00FF00UL) >> 8) | (x & 0x00FF00FFUL) << 8);
x = (x & 0xFFFF0000UL) >> 16) | (x & 0x0000FFFFUL) << 16);
#elif kCharsPerLong == 8
x = (x & 0xFF00FF00FF00FF00UL) >> 8) | (x & 0x00FF00FF00FF00FFUL) << 8);
x = (x & 0xFFFF0000FFFF0000UL) >> 16) | (x & 0x0000FFFF0000FFFFUL) << 16);
x = (x & 0xFFFFFFFF00000000UL) >> 32) | (x & 0x00000000FFFFFFFFUL) << 32);
#else
#error Unsupported word size.
#endif
return x;
}
Для char это не 8 бит (DSP любят это делать), вы сами по себе.(Именно поэтому это было «большое дело», когда серия DSP SHARC имела 8-битные байты; это значительно облегчило перенос существующего кода, поскольку, честно говоря, C выполняет ужасную работу по поддержке переносимости.)
А как насчет буферов произвольной длины?Никаких забавных указателей типов, пожалуйста.
Главное, что можно улучшить с помощью версии OP, - это переосмыслить внутренности цикла.Вместо того, чтобы думать о выходных байтах как о фиксированном регистре данных, думайте о нем как о сдвиговом регистре, где каждый последующий бит сдвинут в правый конец (LSB).Это избавит вас от всех этих разделов и модов (которые, мы надеемся, оптимизированы под сдвиги битов).
Для здравомыслия я отказываюсь от unsigned char для uint8_t.
#include <stdint.h>
unsigned StringToBits(const char* inChars, uint8_t* outBytes, size_t numBytes,
size_t* bytesRead)
/* Converts the string of '1' and '0' characters in `inChars` to a buffer of
* bytes in `outBytes`. `numBytes` is the number of available bytes in the
* `outBytes` buffer. On exit, if `bytesRead` is not NULL, the value it points
* to is set to the number of bytes read (rounding up to the nearest full
* byte). If a multiple of 8 bits is not read, the last byte written will be
* padded with 0 bits to reach a multiple of 8 bits. This function returns the
* number of padding bits that were added. For example, an input of 11 bits
* will result `bytesRead` being set to 2 and the function will return 5. This
* means that if a nonzero value is returned, then a partial byte was read,
* which may be an error.
*/
{ size_t bytes = 0;
unsigned bits = 0;
uint8_t x = 0;
while(bytes < numBytes)
{ /* Parse a character. */
switch(*inChars++)
{ '0': x <<= 1; ++bits; break;
'1': x = (x << 1) | 1; ++bits; break;
default: numBytes = 0;
}
/* See if we filled a byte. */
if(bits == 8)
{ outBytes[bytes++] = x;
x = 0;
bits = 0;
}
}
/* Padding, if needed. */
if(bits)
{ bits = 8 - bits;
outBytes[bytes++] = x << bits;
}
/* Finish up. */
if(bytesRead)
*bytesRead = bytes;
return bits;
}
Вы обязаны убедиться, что inChars имеет нулевое значение.Функция вернется к первому не '0' или '1' символу, который увидит, или если у нее закончится выходной буфер.Некоторые примеры использования:
unsigned char q[32] = "1100111...";
uint8_t buf[4];
size_t bytesRead = 5;
if(StringToBits(q, buf, 4, &bytesRead) || bytesRead != 4)
{
/* Partial read; handle error here. */
}
Это просто читает 4 байта и перехватывает ошибку, если не может.
unsigned char q[4096] = "1100111...";
uint8_t buf[512];
StringToBits(q, buf, 512, NULL);
Это просто конвертирует то, что может, и устанавливает остаток в 0биты.
Эту функцию можно было бы сделать лучше, если бы C имел возможность break из более чем одного уровня цикла или switch;в нынешнем виде мне нужно было бы добавить значение флага, чтобы получить тот же эффект, что и беспорядок, или мне пришлось бы добавить goto, от которого я просто отказываюсь.