C ++でビッグエンディアンとリトルエンディアンの値を変換するにはどうすればよいですか？
C++でビッグエンディアンとリトルエンディアンの値を変換するにはどうすればよいですか？
編集：明確にするために、バイナリデータ（倍精度浮動小数点値と32ビットおよび64ビット整数）を1つのCPUアーキテクチャから別のCPUアーキテクチャに変換する必要があります。これにはネットワーキングが含まれないため、ntoh（）および同様の関数はここでは機能しません。
編集＃2：私が受け入れた答えは、私がターゲットにしているコンパイラに直接適用されます（それが私がそれを選んだ理由です）。ただし、他にも非常に優れた、より移植性の高い回答があります。
Visual C++を使用している場合は、次の手順を実行します。intrin.hをインクルードし、次の関数を呼び出します。
16ビットの数値の場合：
unsigned short _byteswap_ushort(unsigned short value);
32ビットの数値の場合：
unsigned long _byteswap_ulong(unsigned long value);
64ビットの数値の場合：
unsigned __int64 _byteswap_uint64(unsigned __int64 value);
8ビットの数字（文字）を変換する必要はありません。
また、これらは符号付き整数に対しても機能する符号なしの値に対してのみ定義されます。
浮動小数点数と倍精度値の場合、ホストマシンのバイトオーダーにある場合とない場合があるため、プレーン整数の場合よりも困難です。ビッグエンディアンのマシンでリトルエンディアンの浮動小数点数を取得でき、逆も同様です。
他のコンパイラにも同様の組み込み関数があります。
GCCでは、たとえば次のように直接呼び出すことができます。
int32_t __builtin_bswap32 (int32_t x)
int64_t __builtin_bswap64 (int64_t x)
（何かを含める必要はありません）。 Afaik bits.hは、同じ関数を非gcc中心の方法でも宣言します。
16ビットスワップはビットローテーションです。
組み込み関数を呼び出すのではなく、組み込み関数を呼び出すと、最高のパフォーマンスとコード密度が得られます。
簡単に言えば：
#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;
}
使用法：swap_endian<uint32_t>(42)。
FromThe Byte Order FallacyRob Pyke：
データストリームにリトルエンディアンでエンコードされた32ビット整数があるとします。これを抽出する方法は次のとおりです（符号なしバイトを想定）：
i = (data[0]<<0) | (data[1]<<8) | (data[2]<<16) | (data[3]<<24);
ビッグエンディアンの場合、抽出方法は次のとおりです。
i = (data[3]<<0) | (data[2]<<8) | (data[1]<<16) | (data[0]<<24);
TL; DR：プラットフォームのネイティブ順序は気にせず、カウントするのは読み取り中のストリームのバイト順序だけであり、明確に定義されていることを願っています。
注：明示的な型変換がない場合、コメントでコメントされました。dataがunsigned charまたはuint8_tの配列であることが重要です。 signed charまたはchar（符号付きの場合）を使用すると、data[x]が整数に昇格され、data[x] << 24が1を符号ビットUBにシフトする可能性があります。
ネットワーク/ホストの互換性を目的としてこれを行う場合は、次を使用する必要があります。
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)
他の理由でこれを行っている場合、ここに示されているbyte_swapソリューションの1つは問題なく機能します。
私はこの投稿からいくつかの提案を取り、それらをまとめてこれを形成しました：
#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);
}
あなたのためにスワップを行うBSWAPと呼ばれるアセンブリ命令があります。非常に高速です。あなたはそれについて読むことができます ここ 。
Visual Studio、またはより正確にはVisual C++ランタイムライブラリには、_byteswap_ushort(), _byteswap_ulong(), and _byteswap_int64()と呼ばれるこのためのプラットフォーム組み込み関数があります。同様のことが他のプラットフォームにも存在するはずですが、私はそれらが何と呼ばれるかを知りません。
ビッグエンディアンからリトルエンディアンへの移行手順は、リトルエンディアンからビッグエンディアンへの移行と同じです。
コードの例を次に示します。
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);
}
これはテンプレートで行いました。次のようなことができます：
// 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);
}
異なるプラットフォーム間でデータを転送するためにこれを行う場合は、ntohおよびhton関数を調べてください。
Cで行うのと同じ方法：
short big = 0xdead;
short little = (((big & 0xff)<<8) | ((big & 0xff00)>>8));
符号なし文字のベクトルを宣言し、その中に入力値をmemcpyし、バイトを別のベクトルに反転し、バイトをmemcpyで出力することもできますが、特に64ビット値の場合、ビットトゥイドリングよりも桁違いに長くかかります。
ほとんどのPOSIXシステムには（POSIX標準にはないため）、endian.hがあります。これは、システムが使用するエンコードを決定するために使用できます。そこからは次のようになります：
unsigned int change_endian(unsinged int x)
{
unsigned char *ptr = (unsigned char *)&x;
return (ptr[0] << 24) | (ptr[1] << 16) | (ptr[2] << 8) | ptr[3];
}
これは順序を入れ替えます（ビッグエンディアンからリトルエンディアンへ）：
番号が0xDEADBEEFの場合（0xEFBEADDEとして格納されているリトルエンディアンシステム上）、ptr [0]は0xEF、ptr [1]は0xBEなどになります。
ただし、ネットワークに使用する場合は、ホスト順序からネットワーク順序への変換に役立つhton、htonl、htonll（およびそれらの逆ntoh、ntohl、ntohll）が役立ちます。
少なくともWindowsの場合、htonl（）は対応する組み込みの_byteswap_ulong（）よりもはるかに遅いことに注意してください。前者はws2_32.dllへのDLLライブラリ呼び出しで、後者は1つのBSWAPアセンブリ命令です。したがって、プラットフォームに依存するコードを作成する場合は、速度を向上させるために組み込み関数を使用することをお勧めします。
#define htonl(x) _byteswap_ulong(x)
これは、すべての整数が「htonl（）...を使用できる」という説明とともにBig Endianに保存される.PNG画像処理にとって特に重要な場合があります。
私はこれが好きです、ただスタイルのために:-)
long swap(long i) {
char *c = (char *) &i;
return * (long *) (char[]) {c[3], c[2], c[1], c[0] };
}
ほとんどのプラットフォームには、効率的なバイトスワップ機能を提供するシステムヘッダーファイルがあります。 Linuxでは、<endian.h>にあります。 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';
}
出力：
cafe
deadbeaf
feeddeafbeefcafe
真剣に...私はすべての解決策がなぜであるか理解していませんcomplicated！ どのオペレーティングシステムでも、どんな状況でもあらゆるサイズのあらゆるタイプをスワップする、最も単純で最も一般的なテンプレート関数はどうですか????
template <typename T>
void SwapEnd(T& var)
{
char* varArray = reinterpret_cast<char*>(&var);
for(long i = 0; i < static_cast<long>(sizeof(var)/2); i++)
std::swap(varArray[sizeof(var) - 1 - i],varArray[i]);
}
CとC++の魔法の力です！元の変数を文字ごとに単純に交換します。
エンディアンが反転し、コピーコンストラクター（または代入演算子）が機能しない場合、一部のオブジェクトが台無しになるため、単純な代入演算子「=」を使用しなかったことを思い出してください。したがって、文字ごとにコピーする方が信頼性が高くなります。
それを呼び出すには、単に使用します
double x = 5;
SwapEnd(x);
そして今、xはエンディアンネスが異なります。
ビッグエンディアンの32ビット符号なし整数が2864434397に等しい0xAABBCCDDのように見える場合、その同じ32ビット符号なし整数は、同じく2864434397に等しいリトルエンディアンプロセッサの0xDDCCBBAAのように見えます。
ビッグエンディアンの16ビットの符号なしショートが43707に等しい0xAABBのように見える場合、その同じ16ビットの符号なしショートは、同じく43707に等しいリトルエンディアンのプロセッサで0xBBAAのように見えます。
バイトをリトルエンディアンからビッグエンディアンに、またはその逆にスワップする便利な#define関数を次に示します->
// 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))
Host_ENDIAN_ORDER（なんでも）からLITTLE_ENDIAN_ORDERまたはBIG_ENDIAN_ORDERに変換できるこのコードがあります。テンプレートを使用しているため、Host_ENDIAN_ORDERからLITTLE_ENDIAN_ORDERに変換しようとしても、コンパイルするマシンで同じになると、コードは生成されません。
以下にコメント付きのコードを示します。
// 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);
}
どこにも見たことがないので、ここに自分のソリューションを追加したと思いました。これは、小さくて移植性の高いC++テンプレート関数であり、ビット操作のみを使用する移植性があります。
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;
}
これは、値を適切に交換するために、頭の中で思いついた汎用バージョンです。他の提案は、パフォーマンスに問題がある場合に適しています。
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]);
}
免責事項：これをコンパイルしたり、テストしたりしていません。
Wordのビットの順序を逆にする一般的なパターンを採用し、各バイト内のビットを反転する部分を間引くと、Word内のバイトのみを反転するものが残ります。 64ビットの場合：
x = ((x & 0x00000000ffffffff) << 32) ^ ((x >> 32) & 0x00000000ffffffff);
x = ((x & 0x0000ffff0000ffff) << 16) ^ ((x >> 16) & 0x0000ffff0000ffff);
x = ((x & 0x00ff00ff00ff00ff) << 8) ^ ((x >> 8) & 0x00ff00ff00ff00ff);
コンパイラshould余分なビットマスク操作を削除します（パターンを強調するために残しました）が、そうでない場合は、この方法で最初の行を書き換えることができます。
x = ( x << 32) ^ (x >> 32);
通常は、ほとんどのアーキテクチャで単一の回転命令に簡素化されます（操作全体がおそらく1つの命令であることを無視します）。
RISCプロセッサでは、大きく複雑な定数がコンパイラの問題を引き起こす可能性があります。ただし、前の定数から各定数を簡単に計算できます。そのようです：
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);
必要に応じて、ループとして作成できます。効率的ではありませんが、ただ楽しみのために：
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;
}
完全を期すために、最初の形式の単純化された32ビットバージョンを次に示します。
x = ( x << 16) ^ (x >> 16);
x = ((x & 0x00ff00ff) << 8) ^ ((x >> 8) & 0x00ff00ff);
HtobeXXとbetohXXの機能について誰も言及していないことに本当に驚きました。これらはendian.hで定義されており、ネットワーク関数htonXXに非常に似ています。
以下のコードを使用すると、BigEndianと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))
安全な方法は、各Wordでhtonを使用することです。だから、もしあなたが...
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); });
ビッグエンディアンシステムを使用している場合、上記は何もしません。したがって、htonsがno-opかどうかを判断するために、プラットフォームがコンパイル時の条件として使用するものを探します。結局O(n)です。 Macでは、次のようになります...
#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
オプティマイザフレンドリーで非整列の非インプレースエンディアンアクセサを実装するための移植可能な技術。それらはすべてのコンパイラ、すべての境界整列、すべてのバイト順序で動作します。これらのアライメントされていないルーチンは、ネイティブエンディアンとアライメントに応じて、補足またはムートされます。部分的なリストですが、アイデアが得られます。 BO *は、ネイティブのバイト順序に基づいた定数値です。
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];
}
これらのtypedefには、アクセサーで使用されない場合にコンパイラーエラーが発生するという利点があり、忘れられたアクセサーのバグを軽減します。
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 */
最近、Cでこれを行うマクロを作成しましたが、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)
任意の型を受け入れ、渡された引数のバイトを逆にします。使用例：
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]);
}
どの印刷：
Before: ABCDEF0123456789
After : 8967452301EFCDAB
Before: nametag
After : gateman
上記は完全にコピー/貼り付けが可能ですが、ここでは多くのことが行われているため、どのように機能するかを少しずつ説明します。
最初に注目すべきことは、マクロ全体がdo while(0)ブロックに入れられていることです。これは、マクロの後に通常のセミコロンを使用できるようにする 一般的なイディオム です。
次は、forループのカウンターとしてREVERSE_BYTESという名前の変数を使用します。マクロ自体の名前は変数名として使用され、マクロが使用されるあらゆる場所でスコープ内にある他のシンボルと衝突しないようにします。この名前はマクロの展開内で使用されているため、ここで変数名として使用されたときに再び展開されることはありません。
forループ内には、参照されている2バイトと XORスワップ があります（したがって、一時変数名は不要です）。
((unsigned char*)&(__VA_ARGS__))[REVERSE_BYTES]
((unsigned char*)&(__VA_ARGS__))[sizeof(__VA_ARGS__)-1-REVERSE_BYTES]
__VA_ARGS__ は、マクロに与えられたものを表し、渡されるものの柔軟性を高めるために使用されます（あまりではありませんが）。次に、この引数のアドレスが取得され、unsigned charポインターにキャストされて、配列[]添え字によるバイトのスワップが許可されます。
最後の奇妙な点は、{}ブレースの欠如です。各スワップのすべてのステップが カンマ演算子 で結合されており、1つのステートメントになるため、これらは必要ありません。
最後に、速度が最優先事項である場合、これは理想的なアプローチではないことに注意してください。これが重要な要素である場合、他の回答で参照されているタイプ固有のマクロまたはプラットフォーム固有のディレクティブのいくつかが、おそらくより良いオプションです。ただし、このアプローチは、すべてのタイプ、すべての主要なプラットフォーム、およびC言語とC++言語の両方に移植可能です。
ホストコンピューターが別のシステムを使用している場合でも、IEEE 754 64ビット形式で保存されているdoubleを読み取る方法を次に示します。
/*
* 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;
}
}
書き込みルーチンや整数ルーチンを含むその他の一連の関数については、私のgithubプロジェクトを参照してください
テンプレート関数のピボットを中心とした古い3ステップxorトリックによるバイトスワップは、ライブラリを必要としない柔軟で迅速なO(ln2)ソリューションを提供します。ここのスタイルは1バイトタイプも拒否します。
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);
}
}
Boost::endianを試して、自分で実装しないでください！
うわー、私はここで読んだ答えのいくつかを信じることができませんでした。実際、アセンブリには、これを他の何よりも速く実行する命令があります。 bswap。このような関数を簡単に書くことができます...
__declspec(naked) uint32_t EndianSwap(uint32 value)
{
__asm
{
mov eax, dword ptr[esp + 4]
bswap eax
ret
}
}
MUCHは、提案されている組み込み関数よりも高速です。私はそれらを分解して見ました。上記の関数にはプロローグ/エピローグがないため、実質的にオーバーヘッドはありません。
unsigned long _byteswap_ulong(unsigned long value);
Xchg al、ahを使用することを除いて、16ビットを実行するのも簡単です。 bswapは32ビットレジスタでのみ機能します。
64ビットはもう少し複雑ですが、それほど複雑ではありません。ループやテンプレートなどを使用した上記のすべての例よりもはるかに優れています。
ここにいくつかの警告があります...まず、bswapは80x486 CPU以上でのみ利用可能です。 386で実行する予定はありますか？！？もしそうなら、あなたはまだでbswapを置き換えることができます...
mov ebx, eax
shr ebx, 16
xchg bl, bh
xchg al, ah
shl eax, 16
or eax, ebx
また、インラインアセンブリは、Visual Studioのx86コードでのみ使用できます。ネイキッド関数は並べることができず、x64ビルドでは使用できません。その場合、コンパイラ組み込み関数を使用する必要があります。