Мне нужно написать функцию преобразования большого endian в little endian в C. Я не могу использовать какую-либо библиотечную функцию.
Преобразовать большой endian в little endian в C [без использования предоставленного func]
Ответ 1
Предполагая, что вам нужен простой байтовый обмен, попробуйте что-то вроде
Беззнаковое преобразование 16 бит:
swapped = (num>>8) | (num<<8);Беззнаковое 32-битное преобразование:
swapped = ((num>>24)&0xff) | // move byte 3 to byte 0
((num<<8)&0xff0000) | // move byte 1 to byte 2
((num>>8)&0xff00) | // move byte 2 to byte 1
((num<<24)&0xff000000); // byte 0 to byte 3Это свопирует байтовые заказы с позиций 1234 на 4321. Если ваш вход был 0xdeadbeef, 32-разрядная сводная строка может иметь вывод 0xefbeadde.
Приведенный выше код должен быть очищен макросами или, по крайней мере, константами вместо магических чисел, но, надеюсь, он помогает, как и
РЕДАКТИРОВАТЬ: как указывал другой ответ, существуют конкретные варианты платформы, ОС и набора команд, которые могут быть МНОГО быстрее, чем указано выше. В ядре Linux есть макросы (например, cpu_to_be32), которые прекрасно справляются с контентом. Но эти альтернативы специфичны для их окружения. На практике преданность лучше всего использовать сочетание доступных подходов
Ответ 2
Включая:
#include <byteswap.h>
вы можете получить оптимизированную версию зависимых от машины функций байтовой замены. Затем вы можете легко использовать следующие функции:
__bswap_32 (uint32_t input)
или
__bswap_16 (uint16_t input)
Ответ 3
#include <stdint.h>
//! Byte swap unsigned short
uint16_t swap_uint16( uint16_t val )
{
return (val << 8) | (val >> 8 );
}
//! Byte swap short
int16_t swap_int16( int16_t val )
{
return (val << 8) | ((val >> 8) & 0xFF);
}
//! Byte swap unsigned int
uint32_t swap_uint32( uint32_t val )
{
val = ((val << 8) & 0xFF00FF00 ) | ((val >> 8) & 0xFF00FF );
return (val << 16) | (val >> 16);
}
//! Byte swap int
int32_t swap_int32( int32_t val )
{
val = ((val << 8) & 0xFF00FF00) | ((val >> 8) & 0xFF00FF );
return (val << 16) | ((val >> 16) & 0xFFFF);
}
Обновление: добавлено обмен 64-битным байтом
int64_t swap_int64( int64_t val )
{
val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
return (val << 32) | ((val >> 32) & 0xFFFFFFFFULL);
}
uint64_t swap_uint64( uint64_t val )
{
val = ((val << 8) & 0xFF00FF00FF00FF00ULL ) | ((val >> 8) & 0x00FF00FF00FF00FFULL );
val = ((val << 16) & 0xFFFF0000FFFF0000ULL ) | ((val >> 16) & 0x0000FFFF0000FFFFULL );
return (val << 32) | (val >> 32);
}
Ответ 4
Вот довольно общая версия; Я не скомпилировал его, поэтому есть, вероятно, опечатки, но вы должны получить идею,
void SwapBytes(void *pv, size_t n)
{
char *p = pv;
size_t lo, hi;
for(lo=0, hi=n-1; hi>lo; lo++, hi--)
{
char tmp=p[lo];
p[lo] = p[hi];
p[hi] = tmp;
}
}
#define SWAP(x) SwapBytes(&x, sizeof(x));
NB: Это не оптимизировано для скорости или пространства. Он предназначен для ясности (легко отлаживается) и переносимого.
Ответ 5
Если вам нужны макросы (например, встроенная система):
#define SWAP_UINT16(x) (((x) >> 8) | ((x) << 8))
#define SWAP_UINT32(x) (((x) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | ((x) << 24))
Ответ 6
Как шутка:
#include <stdio.h>
int main (int argc, char *argv[])
{
size_t sizeofInt = sizeof (int);
int i;
union
{
int x;
char c[sizeof (int)];
} original, swapped;
original.x = 0x12345678;
for (i = 0; i < sizeofInt; i++)
swapped.c[sizeofInt - i - 1] = original.c[i];
fprintf (stderr, "%x\n", swapped.x);
return 0;
}
Ответ 7
Для всех ваших потребностей, связанных с битками:
Ответ 8
Изменить: Это библиотечные функции. Следующим за ними является ручной способ сделать это.
Я абсолютно ошеломлен количеством людей, которые не знают о __ byteswap_ushort, __byteswap_ulong и __byteswap_uint64. Конечно, они специфичны для Visual С++, но они сводятся к некоторому вкусному коду на архитектуре x86/IA-64.:)
Здесь явное использование инструкции bswap, извлечено из этой страницы. Обратите внимание, что встроенная форма выше всегда будет быстрее, чем эта, я только добавил ее, чтобы дать ответ без библиотечной процедуры.
uint32 cq_ntohl(uint32 a) {
__asm{
mov eax, a;
bswap eax;
}
}
Ответ 9
Будет ли это работать/быстрее?
uint32_t swapped, result;
((byte*)&swapped)[0] = ((byte*)&result)[3];
((byte*)&swapped)[1] = ((byte*)&result)[2];
((byte*)&swapped)[2] = ((byte*)&result)[1];
((byte*)&swapped)[3] = ((byte*)&result)[0];
Ответ 10
здесь, используя инструкцию SSSE3 pshufb, используя встроенный Intel, предполагая, что у вас есть кратное 4 int s:
unsigned int *bswap(unsigned int *destination, unsigned int *source, int length) {
int i;
__m128i mask = _mm_set_epi8(12, 13, 14, 15, 8, 9, 10, 11, 4, 5, 6, 7, 0, 1, 2, 3);
for (i = 0; i < length; i += 4) {
_mm_storeu_si128((__m128i *)&destination[i],
_mm_shuffle_epi8(_mm_loadu_si128((__m128i *)&source[i]), mask));
}
return destination;
}
Ответ 11
EDIT: эта функция заменяет только согласованность 16-битных слов. Функция, часто необходимая для кодировок UTF-16/UCS-2. EDIT END.
Если вы хотите изменить endianess блока памяти, вы можете использовать мой невероятно быстрый подход. Ваш массив памяти должен иметь размер, кратный 8.
#include <stddef.h>
#include <limits.h>
#include <stdint.h>
void ChangeMemEndianness(uint64_t *mem, size_t size)
{
uint64_t m1 = 0xFF00FF00FF00FF00ULL, m2 = m1 >> CHAR_BIT;
size = (size + (sizeof (uint64_t) - 1)) / sizeof (uint64_t);
for(; size; size--, mem++)
*mem = ((*mem & m1) >> CHAR_BIT) | ((*mem & m2) << CHAR_BIT);
}
Эта функция полезна для изменения консистенции Unicode UCS-2/UTF-16.
Ответ 12
Здесь функция, которую я использовал - тестировал и работает с любым базовым типом данных:
// SwapBytes.h
//
// Function to perform in-place endian conversion of basic types
//
// Usage:
//
// double d;
// SwapBytes(&d, sizeof(d));
//
inline void SwapBytes(void *source, int size)
{
typedef unsigned char TwoBytes[2];
typedef unsigned char FourBytes[4];
typedef unsigned char EightBytes[8];
unsigned char temp;
if(size == 2)
{
TwoBytes *src = (TwoBytes *)source;
temp = (*src)[0];
(*src)[0] = (*src)[1];
(*src)[1] = temp;
return;
}
if(size == 4)
{
FourBytes *src = (FourBytes *)source;
temp = (*src)[0];
(*src)[0] = (*src)[3];
(*src)[3] = temp;
temp = (*src)[1];
(*src)[1] = (*src)[2];
(*src)[2] = temp;
return;
}
if(size == 8)
{
EightBytes *src = (EightBytes *)source;
temp = (*src)[0];
(*src)[0] = (*src)[7];
(*src)[7] = temp;
temp = (*src)[1];
(*src)[1] = (*src)[6];
(*src)[6] = temp;
temp = (*src)[2];
(*src)[2] = (*src)[5];
(*src)[5] = temp;
temp = (*src)[3];
(*src)[3] = (*src)[4];
(*src)[4] = temp;
return;
}
}
Ответ 13
Этот фрагмент кода может преобразовать 32-битное маленькое число Endian в число Big Endian.
#include <stdio.h>
main(){
unsigned int i = 0xfafbfcfd;
unsigned int j;
j= ((i&0xff000000)>>24)| ((i&0xff0000)>>8) | ((i&0xff00)<<8) | ((i&0xff)<<24);
printf("unsigned int j = %x\n ", j);
}
Ответ 14
Если вы работаете на процессоре x86 или x86_64, большой endian является родным. так
для 16-битных значений
unsigned short wBigE = value;
unsigned short wLittleE = ((wBigE & 0xFF) << 8) | (wBigE >> 8);
для 32-битных значений
unsigned int iBigE = value;
unsigned int iLittleE = ((iBigE & 0xFF) << 24)
| ((iBigE & 0xFF00) << 8)
| ((iBigE >> 8) & 0xFF00)
| (iBigE >> 24);
Это не самое эффективное решение, если компилятор не признает, что это манипуляция на уровне байтов и генерирует код обмена байтов. Но это не зависит от каких-либо трюков макета памяти и может легко превращаться в макрос.