Help with templatizing function byteswapping, productivity?

Question

template<int size> inline void* byteswap(void* __x); template<> inline void* byteswap<2>(void* __x) { return (*(uint16*)__x >> 8) | (*(uint16*)__x << 8); } template<> inline void* byteswap<4>(void* __x) { return (byteswap<4>(__x & 0xffff) << 16) | (bswap_16 (__x >> 16)); } template<typename T> inline T byteswap(T& swapIt) { return (T*)byteswap<sizeof(T)>(swapIt); } int main() { uint32 i32 = 0x01020304; uint16 i16 = 0x0102; byteswap(i32); byteswap(i16); return 0; } 

The above obviously doesn't even compile. I'm confused because it seems like I need void * as a parameter for a function, and anything else gets ugly in byteswap <4> when I need to call byteswap <2> but with a link.

Any idea how to make this look pretty? Is it possible to achieve this (using built-in or other tricks) in order to do this as performance, as do bit operations directly?

Answer 1

Here is how I code it:

 #include <iostream> typedef unsigned short uint16; typedef unsigned int uint32; template<typename T> T byteswap(T value); template<> uint16 byteswap<uint16>(uint16 value) { return (value >> 8)|(value << 8); } template<> uint32 byteswap<uint32>(uint32 value) { return uint32(byteswap<uint16>(value) << 16) | byteswap<uint16>(value >> 16); } int main() { uint32 i32 = 0x11223344; uint16 i16 = 0x2142; std::cout << std::hex << byteswap(i32) << std::endl; // prints 44332211 std::cout << std::hex << byteswap(i16) << std::endl; // prints 4221 } 

In other words, I would not use size as a template parameter, as you did.

EDIT
sorry my first code was just wrong wrt / uint32 swapping.

Answer 2

Borrowing from some code :

 template<int N> void byteswap_array(char (&bytes)[N]) { // Optimize this with a platform-specific API as desired. for (char *p = bytes, *end = bytes + N - 1; p < end; ++p, --end) { char tmp = *p; *p = *end; *end = tmp; } } template<typename T> T byteswap(T value) { byteswap_array(*reinterpret_cast<char (*)[sizeof(value)]>(&value)); return value; } 

Answer 3

I rewrote it like this:

 template < size_t size > inline void sized_byteswap(char* data); template <> inline void sized_byteswap< 2 >(char* data) { uint16_t* ptr = reinterpret_cast<uint16_t*>(data); *ptr = (*ptr >> 8)|(*ptr << 8); } template <> inline void sized_byteswap< 4 >(char* data) { uint32_t* ptr = reinterpret_cast<uint32_t*>(data); *ptr = (*ptr >> 24)|((*ptr & 0x00ff0000) >> 8)|((*ptr & 0x0000ff00) << 8)|(*ptr << 24); } template < typename T > T byteswap(T value) { sized_byteswap< sizeof(T) >(reinterpret_cast<char*>(&value)); return value; } int main() { uint32 i32 = byteswap(uint32(0x01020304)); uint16 i16 = byteswap(uint16(0x0102)); return 0; } 

Answer 4

I think you are conceptually wrong as the definitions of byteswap (2) and byteswap (4). I do not think, as you have determined, correctly plase refer to the url http://www.iis.sinica.edu.tw/~kathy/vcstl/templates.htm#T6