Comment convertir les valeurs big-endian et little-endian en C++ ?

Question

Comment convertir les valeurs big-endian et little-endian en C++ ?

Pour plus de clarté, je dois traduire des données binaires (valeurs à virgule flottante en double précision et entiers 32 et 64 bits) d'une architecture de CPU à une autre. Cela n'implique pas de mise en réseau, donc ntoh() et les fonctions similaires ne fonctionneront pas ici.

---

Note : La réponse que j'ai acceptée s'applique directement aux compilateurs que je vise (c'est pourquoi je l'ai choisie). Cependant, il y a d'autres très bonnes réponses, plus portables, ici.

Answer 1

Si vous utilisez Visual C++ faites ce qui suit : Vous incluez intrin.h et appelez les fonctions suivantes :

Pour les nombres de 16 bits :

unsigned short _byteswap_ushort(unsigned short value);

Pour les nombres de 32 bits :

unsigned long _byteswap_ulong(unsigned long value);

Pour les nombres de 64 bits :

unsigned __int64 _byteswap_uint64(unsigned __int64 value);

Les nombres de 8 bits (caractères) n'ont pas besoin d'être convertis.

De plus, ils ne sont définis que pour les valeurs non signées ; ils fonctionnent également pour les entiers signés.

Pour les flottants et les doubles, c'est plus difficile qu'avec les entiers ordinaires, car ils peuvent ou non être dans l'ordre des octets de la machine hôte. Vous pouvez obtenir des flottants little-endian sur des machines big-endian et vice versa.

D'autres compilateurs ont également des intrinsèques similaires.

Sur CCG par exemple, vous pouvez appeler directement quelques builtins comme documenté ici :

uint32_t __builtin_bswap32 (uint32_t x)
uint64_t __builtin_bswap64 (uint64_t x)

(pas besoin d'inclure quelque chose). Je crois que bits.h déclare la même fonction d'une manière non centrée sur gcc.

Un échange de 16 bits, c'est juste une rotation de bits.

En appelant les intrinsèques au lieu de développer les vôtres, vous obtenez les meilleures performances et la meilleure densité de code

Answer 2

C'est simple :

#include <climits>

template <typename T>
T swap_endian(T u)
{
    static_assert (CHAR_BIT == 8, "CHAR_BIT != 8");

    union
    {
        T u;
        unsigned char u8[sizeof(T)];
    } source, dest;

    source.u = u;

    for (size_t k = 0; k < sizeof(T); k++)
        dest.u8[k] = source.u8[sizeof(T) - k - 1];

    return dest.u;
}

l'usage : swap_endian<uint32_t>(42) .

Answer 3

Desde L'erreur de l'ordre des octets par Rob Pike :

Disons que votre flux de données contient un entier de 32 bits codé en little-endian. Voici comment l'extraire (en supposant des octets non signés) :

i = (data[0]<<0) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);

Si c'est un big-endian, voici comment l'extraire :

i = (data[3]<<0) | (data[2]<<8) | (data[1]<<16) | (data[0]<<24);

TL;DR : ne vous préoccupez pas de l'ordre natif de votre plateforme, tout ce qui compte c'est l'ordre des octets du flux que vous lisez, et vous avez intérêt à ce qu'il soit bien défini.

_Note : il a été remarqué dans le commentaire qu'en l'absence de conversion explicite de type, il était important que data être un tableau de unsigned char o uint8_t . Utilisation de signed char o char (s'il est signé) aura pour résultat data[x] étant promu à un nombre entier et data[x] << 24 potentiellement en décalant un 1 dans le bit de signe qui est UB._

Answer 4

Si vous faites cela pour des raisons de compatibilité réseau/hôte, vous devez utiliser :

ntohl() //Network to Host byte order (Long)
htonl() //Host to Network byte order (Long)

ntohs() //Network to Host byte order (Short)
htons() //Host to Network byte order (Short)

Si vous faites cela pour une autre raison, l'une des solutions byte_swap présentées ici fonctionnera très bien.

Answer 5

J'ai pris quelques suggestions de ce post et les ai rassemblées pour former ceci :

#include <boost/type_traits.hpp>
#include <boost/static_assert.hpp>
#include <boost/detail/endian.hpp>
#include <stdexcept>
#include <cstdint>

enum endianness
{
    little_endian,
    big_endian,
    network_endian = big_endian,

    #if defined(BOOST_LITTLE_ENDIAN)
        host_endian = little_endian
    #elif defined(BOOST_BIG_ENDIAN)
        host_endian = big_endian
    #else
        #error "unable to determine system endianness"
    #endif
};

namespace detail {

template<typename T, size_t sz>
struct swap_bytes
{
    inline T operator()(T val)
    {
        throw std::out_of_range("data size");
    }
};

template<typename T>
struct swap_bytes<T, 1>
{
    inline T operator()(T val)
    {
        return val;
    }
};

template<typename T>
struct swap_bytes<T, 2>
{
    inline T operator()(T val)
    {
        return ((((val) >> 8) & 0xff) | (((val) & 0xff) << 8));
    }
};

template<typename T>
struct swap_bytes<T, 4>
{
    inline T operator()(T val)
    {
        return ((((val) & 0xff000000) >> 24) |
                (((val) & 0x00ff0000) >>  8) |
                (((val) & 0x0000ff00) <<  8) |
                (((val) & 0x000000ff) << 24));
    }
};

template<>
struct swap_bytes<float, 4>
{
    inline float operator()(float val)
    {
        uint32_t mem =swap_bytes<uint32_t, sizeof(uint32_t)>()(*(uint32_t*)&val);
        return *(float*)&mem;
    }
};

template<typename T>
struct swap_bytes<T, 8>
{
    inline T operator()(T val)
    {
        return ((((val) & 0xff00000000000000ull) >> 56) |
                (((val) & 0x00ff000000000000ull) >> 40) |
                (((val) & 0x0000ff0000000000ull) >> 24) |
                (((val) & 0x000000ff00000000ull) >> 8 ) |
                (((val) & 0x00000000ff000000ull) << 8 ) |
                (((val) & 0x0000000000ff0000ull) << 24) |
                (((val) & 0x000000000000ff00ull) << 40) |
                (((val) & 0x00000000000000ffull) << 56));
    }
};

template<>
struct swap_bytes<double, 8>
{
    inline double operator()(double val)
    {
        uint64_t mem =swap_bytes<uint64_t, sizeof(uint64_t)>()(*(uint64_t*)&val);
        return *(double*)&mem;
    }
};

template<endianness from, endianness to, class T>
struct do_byte_swap
{
    inline T operator()(T value)
    {
        return swap_bytes<T, sizeof(T)>()(value);
    }
};
// specialisations when attempting to swap to the same endianess
template<class T> struct do_byte_swap<little_endian, little_endian, T> { inline T operator()(T value) { return value; } };
template<class T> struct do_byte_swap<big_endian,    big_endian,    T> { inline T operator()(T value) { return value; } };

} // namespace detail

template<endianness from, endianness to, class T>
inline T byte_swap(T value)
{
    // ensure the data is only 1, 2, 4 or 8 bytes
    BOOST_STATIC_ASSERT(sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8);
    // ensure we're only swapping arithmetic types
    BOOST_STATIC_ASSERT(boost::is_arithmetic<T>::value);

    return detail::do_byte_swap<from, to, T>()(value);
}

Vous l'utiliserez alors comme suit :

// swaps val from host-byte-order to network-byte-order
auto swapped = byte_swap<host_endian, network_endian>(val);

et vice-versa

// swap a value received from the network into host-byte-order
auto val = byte_swap<network_endian, host_endian>(val_from_network);