¿Cómo convertir big endian a little endian en C sin usar funciones de biblioteca? [closed]

Question 1

Necesito escribir una función para convertir un entero big endian en un entero little endian en C. No puedo usar ninguna función de biblioteca. ¿Cómo haría esto?

Question 2

Suponiendo que lo que necesita es un simple intercambio de bytes, intente algo como

Conversión de 16 bits sin firmar:

swapped = (num>>8) | (num<<8);

Conversión de 32 bits sin firmar:

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

Esto intercambia los órdenes de bytes de las posiciones 1234 a 4321. Si su entrada fue 0xdeadbeefun intercambio endian de 32 bits podría tener una salida de 0xefbeadde.

El código anterior debe limpiarse con macros o al menos constantes en lugar de números mágicos, pero espero que ayude como está

EDITAR: como señaló otra respuesta, existen alternativas específicas de plataforma, sistema operativo y conjunto de instrucciones que pueden ser MUCHO más rápidas que las anteriores. En el kernel de Linux hay macros (cpu_to_be32 por ejemplo) que manejan el endian bastante bien. Pero estas alternativas son específicas de sus entornos. En la práctica, la endianidad se trata mejor utilizando una combinación de enfoques disponibles.

Question 3

Incluyendo:

#include <byteswap.h>

puede obtener una versión optimizada de las funciones de intercambio de bytes dependientes de la máquina. Luego, puede usar fácilmente las siguientes funciones:

__bswap_32 (uint32_t input)

o

__bswap_16 (uint16_t input)

Question 4

#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);
}

Actualizar : Añadido intercambio de bytes de 64 bits

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);
}

Question 5

Aquí hay una versión bastante genérica; No lo he compilado, por lo que probablemente haya errores tipográficos, pero deberías hacerte una idea,

void SwapBytes(void *pv, size_t n)
{
    assert(n > 0);

    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));

NÓTESE BIEN: Esto es no optimizado para la velocidad o el espacio. Está destinado a ser claro (fácil de depurar) y portátil.

Actualización 2018-04-04
Se agregó la afirmación () para atrapar el caso no válido de n == 0, como lo detectó el comentarista @chux.

Question 6

Si necesita macros (por ejemplo, sistema integrado):

#define SWAP_UINT16(x) (((x) >> 8) | ((x) << 8))
#define SWAP_UINT32(x) (((x) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | ((x) << 24))

Question 7

Editar: Estas son funciones de biblioteca. Seguirlos es la forma manual de hacerlo.

Estoy absolutamente asombrado por la cantidad de personas que desconocen __byteswap_ushort, __byteswap_ulong y __byteswap_uint64. Seguro que son específicos de Visual C++, pero compilan un código delicioso en arquitecturas x86/IA-64. 🙂

He aquí un uso explícito de la bswap instrucción, sacado de esta pagina. Tenga en cuenta que la forma intrínseca anterior siempre ser más rápido que estosolo lo agregué para dar una respuesta sin una rutina de biblioteca.

uint32 cq_ntohl(uint32 a) {
    __asm{
        mov eax, a;
        bswap eax; 
    }
}

Question 8

Como una broma:


#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;
}

¿Ha sido útil esta solución?