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

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

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

EDIT # 2: La réponse que j'ai acceptée s'applique directement aux compilateurs que je cible (c'est pourquoi je l'ai choisi). Cependant, il existe d'autres très bonnes réponses, plus portables ici.

Si vous utilisez Visual C ++, procédez comme suit: Vous incluez intrin.h et appelez les fonctions suivantes:

Pour les nombres à 16 bits:

unsigned short _byteswap_ushort(unsigned short value);

Pour les nombres 32 bits:

unsigned long _byteswap_ulong(unsigned long value);

Pour les nombres 64 bits:

unsigned __int64 _byteswap_uint64(unsigned __int64 value);

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

De plus, ceux-ci 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 que pour les entiers simples, car ceux-ci peuvent ou non être dans l'ordre des octets des machines hôtes. Vous pouvez obtenir des flotteurs little-endian sur des machines big-endian et vice versa.

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

Dans GCC, par exemple, vous pouvez appeler directement certains programmes intégrés comme indiqué ici :

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

(pas besoin d'inclure quelque chose). Afaik bits.h déclare également la même fonction de manière non gcc-centrique.

Swap 16 bits c'est juste une rotation de bits.

Appeler les intrinsèques au lieu de lancer les vôtres vous offre les meilleures performances et densité de code entre les deux.

Tout simplement:

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

utilisation: swap_endian<uint32_t>(42).

Extrait de The Byte Order Fallacy de Rob Pike:

Supposons que votre flux de données comporte un entier 32 bits codé en petit-boutien. 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 du big-endian, voici comment l'extraire:

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

TL; DR: ne vous inquiétez pas de l'ordre natif de votre plate-forme, tout ce qui compte est l'ordre des octets du flux à partir duquel vous lisez, et vous feriez mieux d'espérer qu'il soit bien défini.

Remarque: il a été remarqué dans le commentaire qu'en l'absence de conversion de type explicite, il était important que ce datasoit un tableau de unsigned charou uint8_t. L'utilisation de signed charou char(si signé) entraînera la data[x]promotion en un entier et data[x] << 24éventuellement le décalage d'un 1 dans le bit de signe qui est UB.

Si vous faites cela à des fins 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 fonctionnerait très bien.

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>

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

La procédure pour passer du big-endian au little-endian est la même que pour passer du petit-endian au big-endian.

Voici un exemple de code:

void swapByteOrder(unsigned short& us)
{
    us = (us >> 8) |
         (us << 8);
}

void swapByteOrder(unsigned int& ui)
{
    ui = (ui >> 24) |
         ((ui<<8) & 0x00FF0000) |
         ((ui>>8) & 0x0000FF00) |
         (ui << 24);
}

void swapByteOrder(unsigned long long& ull)
{
    ull = (ull >> 56) |
          ((ull<<40) & 0x00FF000000000000) |
          ((ull<<24) & 0x0000FF0000000000) |
          ((ull<<8) & 0x000000FF00000000) |
          ((ull>>8) & 0x00000000FF000000) |
          ((ull>>24) & 0x0000000000FF0000) |
          ((ull>>40) & 0x000000000000FF00) |
          (ull << 56);
}

Il existe une instruction d'assemblage appelée BSWAP qui fera l'échange pour vous, extrêmement rapidement . Vous pouvez en lire plus ici .

Visual Studio, ou plus précisément la bibliothèque d'exécution Visual C ++, a pour cela des intrinsèques de plate-forme, appelés _byteswap_ushort(), _byteswap_ulong(), and _byteswap_int64(). Des similaires devraient exister pour d'autres plateformes, mais je ne sais pas comment elles s'appelleraient.

Nous l'avons fait avec des modèles. Vous pouvez faire quelque chose comme ça:

// Specialization for 2-byte types.
template<>
inline void endian_byte_swapper< 2 >(char* dest, char const* src)
{
    // Use bit manipulations instead of accessing individual bytes from memory, much faster.
    ushort* p_dest = reinterpret_cast< ushort* >(dest);
    ushort const* const p_src = reinterpret_cast< ushort const* >(src);
    *p_dest = (*p_src >> 8) | (*p_src << 8);
}

// Specialization for 4-byte types.
template<>
inline void endian_byte_swapper< 4 >(char* dest, char const* src)
{
    // Use bit manipulations instead of accessing individual bytes from memory, much faster.
    uint* p_dest = reinterpret_cast< uint* >(dest);
    uint const* const p_src = reinterpret_cast< uint const* >(src);
    *p_dest = (*p_src >> 24) | ((*p_src & 0x00ff0000) >> 8) | ((*p_src & 0x0000ff00) << 8) | (*p_src << 24);
}

Si vous faites cela pour transférer des données entre différentes plates-formes, regardez les fonctions ntoh et hton.

De la même manière que vous le faites en C:

short big = 0xdead;
short little = (((big & 0xff)<<8) | ((big & 0xff00)>>8));

Vous pouvez également déclarer un vecteur de caractères non signés, y mémoriser la valeur d'entrée, inverser les octets dans un autre vecteur et mémoriser les octets, mais cela prendra des ordres de grandeur plus longtemps que le twiddling de bits, en particulier avec les valeurs 64 bits.

Sur la plupart des systèmes POSIX (ce n'est pas dans la norme POSIX), il y a le fichier endian.h, qui peut être utilisé pour déterminer le codage utilisé par votre système. De là, c'est quelque chose comme ça:

unsigned int change_endian(unsigned int x)
{
    unsigned char *ptr = (unsigned char *)&x;
    return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
}

Cela permute l'ordre (du gros endian au petit endian):

Si vous avez le numéro 0xDEADBEEF (sur un petit système endian stocké en tant que 0xEFBEADDE), ptr [0] sera 0xEF, ptr [1] est 0xBE, etc.

Mais si vous souhaitez l'utiliser pour la mise en réseau, alors htons, htonl et htonll (et leurs inverses ntohs, ntohl et ntohll) seront utiles pour la conversion de l'ordre de l'hôte à l'ordre du réseau.

Notez que, au moins pour Windows, htonl () est beaucoup plus lent que son homologue intrinsèque _byteswap_ulong (). Le premier est un appel de bibliothèque DLL dans ws2_32.dll, le second est une instruction d'assemblage BSWAP. Par conséquent, si vous écrivez du code dépendant de la plate-forme, préférez utiliser les intrinsèques pour la vitesse:

#define htonl(x) _byteswap_ulong(x)

Cela peut être particulièrement important pour le traitement d'image .PNG où tous les entiers sont enregistrés dans Big Endian avec l'explication "On peut utiliser htonl () ..." {pour ralentir les programmes Windows typiques, si vous n'êtes pas préparé}.

La plupart des plates-formes ont un fichier d'en-tête système qui fournit des fonctions d'octetswap efficaces. Sous Linux, c'est dans <endian.h>. Vous pouvez bien l'envelopper en C ++:

#include <iostream>

#include <endian.h>

template<size_t N> struct SizeT {};

#define BYTESWAPS(bits) \
template<class T> inline T htobe(T t, SizeT<bits / 8>) { return htobe ## bits(t); } \
template<class T> inline T htole(T t, SizeT<bits / 8>) { return htole ## bits(t); } \
template<class T> inline T betoh(T t, SizeT<bits / 8>) { return be ## bits ## toh(t); } \
template<class T> inline T letoh(T t, SizeT<bits / 8>) { return le ## bits ## toh(t); }

BYTESWAPS(16)
BYTESWAPS(32)
BYTESWAPS(64)

#undef BYTESWAPS

template<class T> inline T htobe(T t) { return htobe(t, SizeT<sizeof t>()); }
template<class T> inline T htole(T t) { return htole(t, SizeT<sizeof t>()); }
template<class T> inline T betoh(T t) { return betoh(t, SizeT<sizeof t>()); }
template<class T> inline T letoh(T t) { return letoh(t, SizeT<sizeof t>()); }

int main()
{
    std::cout << std::hex;
    std::cout << htobe(static_cast<unsigned short>(0xfeca)) << '\n';
    std::cout << htobe(0xafbeadde) << '\n';

    // Use ULL suffix to specify integer constant as unsigned long long 
    std::cout << htobe(0xfecaefbeafdeedfeULL) << '\n';
}

Production:

cafe
deadbeaf
feeddeafbeefcafe

j'aime celui-ci, juste pour le style :-)

long swap(long i) {
    char *c = (char *) &i;
    return * (long *) (char[]) {c[3], c[2], c[1], c[0] };
}

Sérieusement ... je ne comprends pas pourquoi toutes les solutions sont si compliquées ! Que diriez-vous de la fonction de modèle la plus simple et la plus générale qui permute tout type de n'importe quelle taille en toutes circonstances dans n'importe quel système d'exploitation ????

template <typename T>
void SwapEnd(T& var)
{
    static_assert(std::is_pod<T>::value, "Type must be POD type for safety");
    std::array<char, sizeof(T)> varArray;
    std::memcpy(varArray.data(), &var, sizeof(T));
    for(int i = 0; i < static_cast<int>(sizeof(var)/2); i++)
        std::swap(varArray[sizeof(var) - 1 - i],varArray[i]);
    std::memcpy(&var, varArray.data(), sizeof(T));
}

C'est le pouvoir magique du C et du C ++ ensemble! Échangez simplement la variable d'origine caractère par caractère.

Point 1 : Aucun opérateur: N'oubliez pas que je n'ai pas utilisé l'opérateur d'affectation simple "=" car certains objets seront gâchés lorsque l'endianisme sera inversé et le constructeur de copie (ou l'opérateur d'affectation) ne fonctionnera pas. Par conséquent, il est plus fiable de les copier caractère par caractère.

Point 2 : Soyez conscient des problèmes d'alignement: notez que nous copions vers et depuis un tableau, ce qui est la bonne chose à faire car le compilateur C ++ ne garantit pas que nous pouvons accéder à la mémoire non alignée (cette réponse a été mise à jour à partir de son original formulaire pour cela). Par exemple, si vous allouez uint64_t, votre compilateur ne peut pas garantir que vous pouvez accéder au 3e octet de cela en tant que uint8_t. Par conséquent, la bonne chose à faire est de le copier dans un tableau de caractères, de l'échanger, puis de le recopier (donc non reinterpret_cast). Notez que les compilateurs sont généralement assez intelligents pour convertir ce que vous avez fait en reinterpret_casts'ils sont capables d'accéder à des octets individuels indépendamment de l'alignement.

Pour utiliser cette fonction :

double x = 5;
SwapEnd(x);

et xest maintenant différent dans l'endianisme.

J'ai ce code qui me permet de convertir de HOST_ENDIAN_ORDER (quel qu'il soit) en LITTLE_ENDIAN_ORDER ou BIG_ENDIAN_ORDER. J'utilise un modèle, donc si j'essaie de convertir de HOST_ENDIAN_ORDER en LITTLE_ENDIAN_ORDER et qu'ils se trouvent être les mêmes pour la machine pour laquelle je compile, aucun code ne sera généré.

Voici le code avec quelques commentaires:

// We define some constant for little, big and host endianess. Here I use 
// BOOST_LITTLE_ENDIAN/BOOST_BIG_ENDIAN to check the host indianess. If you
// don't want to use boost you will have to modify this part a bit.
enum EEndian
{
  LITTLE_ENDIAN_ORDER,
  BIG_ENDIAN_ORDER,
#if defined(BOOST_LITTLE_ENDIAN)
  HOST_ENDIAN_ORDER = LITTLE_ENDIAN_ORDER
#elif defined(BOOST_BIG_ENDIAN)
  HOST_ENDIAN_ORDER = BIG_ENDIAN_ORDER
#else
#error "Impossible de determiner l'indianness du systeme cible."
#endif
};

// this function swap the bytes of values given it's size as a template
// parameter (could sizeof be used?).
template <class T, unsigned int size>
inline T SwapBytes(T value)
{
  union
  {
     T value;
     char bytes[size];
  } in, out;

  in.value = value;

  for (unsigned int i = 0; i < size / 2; ++i)
  {
     out.bytes[i] = in.bytes[size - 1 - i];
     out.bytes[size - 1 - i] = in.bytes[i];
  }

  return out.value;
}

// Here is the function you will use. Again there is two compile-time assertion
// that use the boost librarie. You could probably comment them out, but if you
// do be cautious not to use this function for anything else than integers
// types. This function need to be calles like this :
//
//     int x = someValue;
//     int i = EndianSwapBytes<HOST_ENDIAN_ORDER, BIG_ENDIAN_ORDER>(x);
//
template<EEndian from, EEndian to, class T>
inline T EndianSwapBytes(T value)
{
  // A : La donnée à swapper à une taille de 2, 4 ou 8 octets
  BOOST_STATIC_ASSERT(sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8);

  // A : La donnée à swapper est d'un type arithmetic
  BOOST_STATIC_ASSERT(boost::is_arithmetic<T>::value);

  // Si from et to sont du même type on ne swap pas.
  if (from == to)
     return value;

  return SwapBytes<T, sizeof(T)>(value);
}

Si un entier non signé big-endian 32 bits ressemble à 0xAABBCCDD qui est égal à 2864434397, alors ce même entier non signé 32 bits ressemble à 0xDDCCBBAA sur un processeur little-endian qui est également égal à 2864434397.

Si un court-circuit non signé 16 bits big-endian ressemble à 0xAABB qui est égal à 43707, alors ce même short non-signé 16 bits ressemble à 0xBBAA sur un processeur little-endian qui est également égal à 43707.

Voici quelques fonctions #define pratiques pour échanger des octets de little-endian à big-endian et vice-versa ->

// can be used for short, unsigned short, word, unsigned word (2-byte types)
#define BYTESWAP16(n) (((n&0xFF00)>>8)|((n&0x00FF)<<8))

// can be used for int or unsigned int or float (4-byte types)
#define BYTESWAP32(n) ((BYTESWAP16((n&0xFFFF0000)>>16))|((BYTESWAP16(n&0x0000FFFF))<<16))

// can be used for unsigned long long or double (8-byte types)
#define BYTESWAP64(n) ((BYTESWAP32((n&0xFFFFFFFF00000000)>>32))|((BYTESWAP32(n&0x00000000FFFFFFFF))<<32))

Voici une version généralisée que j'ai inventée du haut de ma tête, pour échanger une valeur en place. Les autres suggestions seraient meilleures si les performances sont un problème.

 template<typename T>
    void ByteSwap(T * p)
    {
        for (int i = 0;  i < sizeof(T)/2;  ++i)
            std::swap(((char *)p)[i], ((char *)p)[sizeof(T)-1-i]);
    }

Avertissement: je n'ai pas encore essayé de le compiler ou de le tester.

Si vous prenez le modèle commun pour inverser l'ordre des bits dans un mot et supprimez la partie qui inverse les bits dans chaque octet, vous vous retrouvez avec quelque chose qui inverse uniquement les octets dans un mot. Pour 64 bits:

x = ((x & 0x00000000ffffffff) << 32) ^ ((x >> 32) & 0x00000000ffffffff);
x = ((x & 0x0000ffff0000ffff) << 16) ^ ((x >> 16) & 0x0000ffff0000ffff);
x = ((x & 0x00ff00ff00ff00ff) <<  8) ^ ((x >>  8) & 0x00ff00ff00ff00ff);

Le compilateur devrait nettoyer les opérations de masquage de bits superflues (je les ai laissées pour mettre en surbrillance le modèle), mais si ce n'est pas le cas, vous pouvez réécrire la première ligne de cette façon:

x = ( x                       << 32) ^  (x >> 32);

Cela devrait normalement se réduire à une seule instruction de rotation sur la plupart des architectures (sans tenir compte du fait que toute l'opération est probablement une instruction).

Sur un processeur RISC, les grandes constantes compliquées peuvent entraîner des difficultés de compilation. Cependant, vous pouvez calculer trivialement chacune des constantes de la précédente. Ainsi:

uint64_t k = 0x00000000ffffffff; /* compiler should know a trick for this */
x = ((x & k) << 32) ^ ((x >> 32) & k);
k ^= k << 16;
x = ((x & k) << 16) ^ ((x >> 16) & k);
k ^= k << 8;
x = ((x & k) <<  8) ^ ((x >>  8) & k);

Si vous le souhaitez, vous pouvez l'écrire en boucle. Ce ne sera pas efficace, mais juste pour le plaisir:

int i = sizeof(x) * CHAR_BIT / 2;
uintmax_t k = (1 << i) - 1;
while (i >= 8)
{
    x = ((x & k) << i) ^ ((x >> i) & k);
    i >>= 1;
    k ^= k << i;
}

Et pour être complet, voici la version 32 bits simplifiée du premier formulaire:

x = ( x               << 16) ^  (x >> 16);
x = ((x & 0x00ff00ff) <<  8) ^ ((x >>  8) & 0x00ff00ff);

Je pensais juste avoir ajouté ma propre solution ici car je ne l'ai vue nulle part. C'est une petite fonction portable et basée sur un modèle C ++ et portable qui utilise uniquement des opérations de bits.

template<typename T> inline static T swapByteOrder(const T& val) {
    int totalBytes = sizeof(val);
    T swapped = (T) 0;
    for (int i = 0; i < totalBytes; ++i) {
        swapped |= (val >> (8*(totalBytes-i-1)) & 0xFF) << (8*i);
    }
    return swapped;
}

Je suis vraiment surpris que personne n'ait mentionné les fonctions htobeXX et betohXX. Ils sont définis dans endian.h et sont très similaires aux fonctions réseau htonXX.

En utilisant les codes ci-dessous, vous pouvez facilement basculer entre BigEndian et LittleEndian

#define uint32_t unsigned 
#define uint16_t unsigned short

#define swap16(x) ((((uint16_t)(x) & 0x00ff)<<8)| \
(((uint16_t)(x) & 0xff00)>>8))

#define swap32(x) ((((uint32_t)(x) & 0x000000ff)<<24)| \
(((uint32_t)(x) & 0x0000ff00)<<8)| \
(((uint32_t)(x) & 0x00ff0000)>>8)| \
(((uint32_t)(x) & 0xff000000)>>24))

J'ai récemment écrit une macro pour le faire en C, mais elle est également valable en C ++:

#define REVERSE_BYTES(...) do for(size_t REVERSE_BYTES=0; REVERSE_BYTES<sizeof(__VA_ARGS__)>>1; ++REVERSE_BYTES)\
    ((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES] ^= ((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES],\
    ((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES] ^= ((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES],\
    ((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES] ^= ((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES];\
while(0)

Il accepte n'importe quel type et inverse les octets dans l'argument passé. Exemples d'utilisations:

int main(){
    unsigned long long x = 0xABCDEF0123456789;
    printf("Before: %llX\n",x);
    REVERSE_BYTES(x);
    printf("After : %llX\n",x);

    char c[7]="nametag";
    printf("Before: %c%c%c%c%c%c%c\n",c[0],c[1],c[2],c[3],c[4],c[5],c[6]);
    REVERSE_BYTES(c);
    printf("After : %c%c%c%c%c%c%c\n",c[0],c[1],c[2],c[3],c[4],c[5],c[6]);
}

Qui imprime:

Before: ABCDEF0123456789
After : 8967452301EFCDAB
Before: nametag
After : gateman

Ce qui précède est parfaitement copiable / collable, mais il se passe beaucoup de choses ici, donc je vais vous expliquer comment cela fonctionne pièce par pièce:

La première chose notable est que la macro entière est enfermée dans un do while(0)bloc. Ceci est un idiome commun permettant l'utilisation normale des points-virgules après la macro.

Ensuite, l'utilisation d'une variable nommée REVERSE_BYTEScomme forcompteur de boucle. Le nom de la macro lui-même est utilisé comme nom de variable pour garantir qu'il n'entre pas en conflit avec d'autres symboles qui peuvent être dans le champ d'application partout où la macro est utilisée. Étant donné que le nom est utilisé dans l'expansion de la macro, il ne sera pas développé à nouveau lorsqu'il est utilisé comme nom de variable ici.

Dans la forboucle, deux octets sont référencés et XOR échangés (un nom de variable temporaire n'est donc pas requis):

((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES]
((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES]

__VA_ARGS__représente tout ce qui a été donné à la macro et est utilisé pour augmenter la flexibilité de ce qui peut être transmis (quoique pas beaucoup). L'adresse de cet argument est ensuite prise et transtypée en un unsigned charpointeur pour permettre l'échange de ses octets via un []indice de tableau .

Le dernier point particulier est le manque d' {}appareils orthopédiques. Ils ne sont pas nécessaires car toutes les étapes de chaque échange sont jointes à l' opérateur virgule , ce qui en fait une instruction.

Enfin, il convient de noter que ce n'est pas l'approche idéale si la vitesse est une priorité absolue. S'il s'agit d'un facteur important, certaines des macros spécifiques au type ou des directives spécifiques à la plate-forme référencées dans d'autres réponses sont probablement une meilleure option. Cette approche, cependant, est portable pour tous les types, toutes les principales plates-formes et les langages C et C ++.

Wow, je ne pouvais pas croire certaines des réponses que j'ai lues ici. Il y a en fait une instruction d'assemblage qui le fait plus rapidement qu'autre chose. bswap. Vous pouvez simplement écrire une fonction comme celle-ci ...

__declspec(naked) uint32_t EndianSwap(uint32 value)
{
    __asm
    {
        mov eax, dword ptr[esp + 4]
        bswap eax
        ret
    }
}

C'est BEAUCOUP plus rapide que les intrinsèques qui ont été suggérées. Je les ai démontés et j'ai regardé. La fonction ci-dessus n'a pas de prologue / épilogue et n'a donc pratiquement aucun frais généraux.

unsigned long _byteswap_ulong(unsigned long value);

Faire 16 bits est tout aussi simple, à l'exception que vous utiliseriez xchg al, ah. bswap ne fonctionne que sur les registres 32 bits.

64 bits est un peu plus délicat, mais pas trop. Beaucoup mieux que tous les exemples ci-dessus avec des boucles et des modèles, etc.

Il y a quelques mises en garde ici ... Tout d'abord, bswap n'est disponible que sur les processeurs 80x486 et supérieurs. Est-ce que quelqu'un envisage de le faire fonctionner sur un 386?!? Si c'est le cas, vous pouvez toujours remplacer bswap par ...

mov ebx, eax
shr ebx, 16
xchg bl, bh
xchg al, ah
shl eax, 16
or eax, ebx

L'assemblage en ligne n'est également disponible qu'en code x86 dans Visual Studio. Une fonction nue ne peut pas être doublée et n'est pas non plus disponible dans les versions x64. Dans ce cas, vous allez devoir utiliser les caractéristiques intrinsèques du compilateur.

Technique portable pour implémenter des accesseurs endiens non alignés non alignés et optimisés. Ils fonctionnent sur chaque compilateur, chaque alignement de frontière et chaque ordre d'octets. Ces routines non alignées sont complétées ou évoquées, selon l'endian natif et l'alignement. Liste partielle mais vous avez l'idée. BO * sont des valeurs constantes basées sur l'ordre des octets natifs.

uint32_t sw_get_uint32_1234(pu32)
uint32_1234 *pu32;
{
  union {
    uint32_1234 u32_1234;
    uint32_t u32;
  } bou32;
  bou32.u32_1234[0] = (*pu32)[BO32_0];
  bou32.u32_1234[1] = (*pu32)[BO32_1];
  bou32.u32_1234[2] = (*pu32)[BO32_2];
  bou32.u32_1234[3] = (*pu32)[BO32_3];
  return(bou32.u32);
}

void sw_set_uint32_1234(pu32, u32)
uint32_1234 *pu32;
uint32_t u32;
{
  union {
    uint32_1234 u32_1234;
    uint32_t u32;
  } bou32;
  bou32.u32 = u32;
  (*pu32)[BO32_0] = bou32.u32_1234[0];
  (*pu32)[BO32_1] = bou32.u32_1234[1];
  (*pu32)[BO32_2] = bou32.u32_1234[2];
  (*pu32)[BO32_3] = bou32.u32_1234[3];
}

#if HAS_SW_INT64
int64 sw_get_int64_12345678(pi64)
int64_12345678 *pi64;
{
  union {
    int64_12345678 i64_12345678;
    int64 i64;
  } boi64;
  boi64.i64_12345678[0] = (*pi64)[BO64_0];
  boi64.i64_12345678[1] = (*pi64)[BO64_1];
  boi64.i64_12345678[2] = (*pi64)[BO64_2];
  boi64.i64_12345678[3] = (*pi64)[BO64_3];
  boi64.i64_12345678[4] = (*pi64)[BO64_4];
  boi64.i64_12345678[5] = (*pi64)[BO64_5];
  boi64.i64_12345678[6] = (*pi64)[BO64_6];
  boi64.i64_12345678[7] = (*pi64)[BO64_7];
  return(boi64.i64);
}
#endif

int32_t sw_get_int32_3412(pi32)
int32_3412 *pi32;
{
  union {
    int32_3412 i32_3412;
    int32_t i32;
  } boi32;
  boi32.i32_3412[2] = (*pi32)[BO32_0];
  boi32.i32_3412[3] = (*pi32)[BO32_1];
  boi32.i32_3412[0] = (*pi32)[BO32_2];
  boi32.i32_3412[1] = (*pi32)[BO32_3];
  return(boi32.i32);
}

void sw_set_int32_3412(pi32, i32)
int32_3412 *pi32;
int32_t i32;
{
  union {
    int32_3412 i32_3412;
    int32_t i32;
  } boi32;
  boi32.i32 = i32;
  (*pi32)[BO32_0] = boi32.i32_3412[2];
  (*pi32)[BO32_1] = boi32.i32_3412[3];
  (*pi32)[BO32_2] = boi32.i32_3412[0];
  (*pi32)[BO32_3] = boi32.i32_3412[1];
}

uint32_t sw_get_uint32_3412(pu32)
uint32_3412 *pu32;
{
  union {
    uint32_3412 u32_3412;
    uint32_t u32;
  } bou32;
  bou32.u32_3412[2] = (*pu32)[BO32_0];
  bou32.u32_3412[3] = (*pu32)[BO32_1];
  bou32.u32_3412[0] = (*pu32)[BO32_2];
  bou32.u32_3412[1] = (*pu32)[BO32_3];
  return(bou32.u32);
}

void sw_set_uint32_3412(pu32, u32)
uint32_3412 *pu32;
uint32_t u32;
{
  union {
    uint32_3412 u32_3412;
    uint32_t u32;
  } bou32;
  bou32.u32 = u32;
  (*pu32)[BO32_0] = bou32.u32_3412[2];
  (*pu32)[BO32_1] = bou32.u32_3412[3];
  (*pu32)[BO32_2] = bou32.u32_3412[0];
  (*pu32)[BO32_3] = bou32.u32_3412[1];
}

float sw_get_float_1234(pf)
float_1234 *pf;
{
  union {
    float_1234 f_1234;
    float f;
  } bof;
  bof.f_1234[0] = (*pf)[BO32_0];
  bof.f_1234[1] = (*pf)[BO32_1];
  bof.f_1234[2] = (*pf)[BO32_2];
  bof.f_1234[3] = (*pf)[BO32_3];
  return(bof.f);
}

void sw_set_float_1234(pf, f)
float_1234 *pf;
float f;
{
  union {
    float_1234 f_1234;
    float f;
  } bof;
  bof.f = (float)f;
  (*pf)[BO32_0] = bof.f_1234[0];
  (*pf)[BO32_1] = bof.f_1234[1];
  (*pf)[BO32_2] = bof.f_1234[2];
  (*pf)[BO32_3] = bof.f_1234[3];
}

double sw_get_double_12345678(pd)
double_12345678 *pd;
{
  union {
    double_12345678 d_12345678;
    double d;
  } bod;
  bod.d_12345678[0] = (*pd)[BO64_0];
  bod.d_12345678[1] = (*pd)[BO64_1];
  bod.d_12345678[2] = (*pd)[BO64_2];
  bod.d_12345678[3] = (*pd)[BO64_3];
  bod.d_12345678[4] = (*pd)[BO64_4];
  bod.d_12345678[5] = (*pd)[BO64_5];
  bod.d_12345678[6] = (*pd)[BO64_6];
  bod.d_12345678[7] = (*pd)[BO64_7];
  return(bod.d);
}

void sw_set_double_12345678(pd, d)
double_12345678 *pd;
double d;
{
  union {
    double_12345678 d_12345678;
    double d;
  } bod;
  bod.d = d;
  (*pd)[BO64_0] = bod.d_12345678[0];
  (*pd)[BO64_1] = bod.d_12345678[1];
  (*pd)[BO64_2] = bod.d_12345678[2];
  (*pd)[BO64_3] = bod.d_12345678[3];
  (*pd)[BO64_4] = bod.d_12345678[4];
  (*pd)[BO64_5] = bod.d_12345678[5];
  (*pd)[BO64_6] = bod.d_12345678[6];
  (*pd)[BO64_7] = bod.d_12345678[7];
}

Ces typedefs ont l'avantage de générer des erreurs de compilation s'ils ne sont pas utilisés avec des accesseurs, atténuant ainsi les bogues oubliés des accesseurs.

typedef char int8_1[1], uint8_1[1];

typedef char int16_12[2], uint16_12[2]; /* little endian */
typedef char int16_21[2], uint16_21[2]; /* big endian */

typedef char int24_321[3], uint24_321[3]; /* Alpha Micro, PDP-11 */

typedef char int32_1234[4], uint32_1234[4]; /* little endian */
typedef char int32_3412[4], uint32_3412[4]; /* Alpha Micro, PDP-11 */
typedef char int32_4321[4], uint32_4321[4]; /* big endian */

typedef char int64_12345678[8], uint64_12345678[8]; /* little endian */
typedef char int64_34128756[8], uint64_34128756[8]; /* Alpha Micro, PDP-11 */
typedef char int64_87654321[8], uint64_87654321[8]; /* big endian */

typedef char float_1234[4]; /* little endian */
typedef char float_3412[4]; /* Alpha Micro, PDP-11 */
typedef char float_4321[4]; /* big endian */

typedef char double_12345678[8]; /* little endian */
typedef char double_78563412[8]; /* Alpha Micro? */
typedef char double_87654321[8]; /* big endian */

Voici comment lire un double stocké au format IEEE 754 64 bits, même si votre ordinateur hôte utilise un système différent.

/*
* read a double from a stream in ieee754 format regardless of host
*  encoding.
*  fp - the stream
*  bigendian - set to if big bytes first, clear for little bytes
*              first
*
*/
double freadieee754(FILE *fp, int bigendian)
{
    unsigned char buff[8];
    int i;
    double fnorm = 0.0;
    unsigned char temp;
    int sign;
    int exponent;
    double bitval;
    int maski, mask;
    int expbits = 11;
    int significandbits = 52;
    int shift;
    double answer;

    /* read the data */
    for (i = 0; i < 8; i++)
        buff[i] = fgetc(fp);
    /* just reverse if not big-endian*/
    if (!bigendian)
    {
        for (i = 0; i < 4; i++)
        {
            temp = buff[i];
            buff[i] = buff[8 - i - 1];
            buff[8 - i - 1] = temp;
        }
    }
    sign = buff[0] & 0x80 ? -1 : 1;
    /* exponet in raw format*/
    exponent = ((buff[0] & 0x7F) << 4) | ((buff[1] & 0xF0) >> 4);

    /* read inthe mantissa. Top bit is 0.5, the successive bits half*/
    bitval = 0.5;
    maski = 1;
    mask = 0x08;
    for (i = 0; i < significandbits; i++)
    {
        if (buff[maski] & mask)
            fnorm += bitval;

        bitval /= 2.0;
        mask >>= 1;
        if (mask == 0)
        {
            mask = 0x80;
            maski++;
        }
    }
    /* handle zero specially */
    if (exponent == 0 && fnorm == 0)
        return 0.0;

    shift = exponent - ((1 << (expbits - 1)) - 1); /* exponent = shift + bias */
    /* nans have exp 1024 and non-zero mantissa */
    if (shift == 1024 && fnorm != 0)
        return sqrt(-1.0);
    /*infinity*/
    if (shift == 1024 && fnorm == 0)
    {

#ifdef INFINITY
        return sign == 1 ? INFINITY : -INFINITY;
#endif
        return  (sign * 1.0) / 0.0;
    }
    if (shift > -1023)
    {
        answer = ldexp(fnorm + 1.0, shift);
        return answer * sign;
    }
    else
    {
        /* denormalised numbers */
        if (fnorm == 0.0)
            return 0.0;
        shift = -1022;
        while (fnorm < 1.0)
        {
            fnorm *= 2;
            shift--;
        }
        answer = ldexp(fnorm, shift);
        return answer * sign;
    }
}

Pour le reste de la suite de fonctions, y compris les routines d'écriture et d'entier, voir mon projet github

https://github.com/MalcolmMcLean/ieee754

L'échange d'octets avec une astuce en trois étapes autour d'un pivot dans une fonction de modèle donne une solution O (ln2) flexible et rapide qui ne nécessite pas de bibliothèque, le style ici rejette également les types à 1 octet:

template<typename T>void swap(T &t){
    for(uint8_t pivot = 0; pivot < sizeof(t)/2; pivot ++){
        *((uint8_t *)&t + pivot) ^= *((uint8_t *)&t+sizeof(t)-1- pivot);
        *((uint8_t *)&t+sizeof(t)-1- pivot) ^= *((uint8_t *)&t + pivot);
        *((uint8_t *)&t + pivot) ^= *((uint8_t *)&t+sizeof(t)-1- pivot);
    }
}

Il semble que le moyen le plus sûr serait d'utiliser des htons sur chaque mot. Donc, si vous avez ...

std::vector<uint16_t> storage(n);  // where n is the number to be converted

// the following would do the trick
std::transform(word_storage.cbegin(), word_storage.cend()
  , word_storage.begin(), [](const uint16_t input)->uint16_t {
  return htons(input); });

Ce qui précède serait un no-op si vous étiez sur un système big-endian, donc je chercherais tout ce que votre plate-forme utilise comme condition de compilation pour décider si htons est un no-op. C'est O (n) après tout. Sur un Mac, ce serait quelque chose comme ...

#if (__DARWIN_BYTE_ORDER != __DARWIN_BIG_ENDIAN)
std::transform(word_storage.cbegin(), word_storage.cend()
  , word_storage.begin(), [](const uint16_t input)->uint16_t {
  return htons(input); });
#endif

Si vous avez C ++ 17, ajoutez cet en-tête

#include <algorithm>

Utilisez cette fonction de modèle pour échanger les octets:

template <typename T>
void swapEndian(T& buffer)
{
    static_assert(std::is_pod<T>::value, "swapEndian support POD type only");
    char* startIndex = static_cast<char*>((void*)buffer.data());
    char* endIndex = startIndex + sizeof(buffer);
    std::reverse(startIndex, endIndex);
}

appelez-le comme:

swapEndian (stlContainer);

Recherchez le décalage de bits, car c'est essentiellement tout ce que vous devez faire pour échanger de petit -> gros endian. Ensuite, en fonction de la taille du bit, vous modifiez la façon dont vous effectuez le décalage des bits.