Wie C++ 14.11 zu verwenden, um diese Umsetzung

Question

Geschichte zu vereinfachen ein wenig lang ist, ist es eine Endian-Universal-Implementierung für ganze Zahl ist, ist die ursprüngliche Code wie zum Beispiel:

#ifdef _BIG_ENDIAN_ 
#define ENDIANUSHORT(src)  (unsigned short)src 
#define ENDIANULONG(src)  (unsigned long)src 
#define ENDIANUINT64(src)  (unsigned long long)src 
#else 
#define ENDIANUSHORT(src)  ((unsigned short)((((src)>>8)&0xff) |\ 
               (((src)<<8)&0xff00))) 

#define ENDIANULONG(src)  ((unsigned long)((((src)>>24)&0xFF) |\ 
               (((src)>> 8)&0xFF00) |\ 
               (((src)<< 8)&0xFF0000) |\ 
               (((src)<<24)&0xFF000000))) 

#define ENDIANUINT64(src)  ((unsigned long long)((((src)>>56)&0xFF) |\ 
               (((src)>>40)&0xFF00) |\ 
               (((src)>>24)&0xFF0000) |\ 
               (((src)>> 8)&0xFF000000) |\ 
               (((src)<< 8)&0xFF00000000LL) |\ 
               (((src)<<24)&0xFF0000000000LL) |\ 
               (((src)<<40)&0xFF000000000000LL) |\ 
               (((src)<<56)&0xFF00000000000000LL))) 
#endif //_BIG_ENDIAN_ 

template< 
    typename T, 
    typename std::enable_if<std::numeric_limits<T>::is_integer>::type* = nullptr> 
T _endian(T& t) { 
if (sizeof(T) == 2) 
    return ENDIANUSHORT(t); 
else if (sizeof(T) == 4) 
    return ENDIANULONG(t); 
else if (sizeof(T) == 8) 
    return ENDIANUINT64(t); 

return t; 
} 

template<typename T> 
void endian(T& t) { t = _endian(t); } 

int main() 
{ 
    long lv = 123; 
    endian(lv); 
    ...... 
} 

Es funktioniert gut, aber es wie in MSVC sind Warnungen wie:

warning C4293: '>>': shift count negative or too big, undefined behavior 

Dann verfeinert er als: T _endian Ersetzen (T & t) mit dem folgenden Code definieren:

static int64_t _endian(int64_t t) { 
    return ENDIANUINT64(t); 
} 

static uint64_t _endian(uint64_t t) { 
    return ENDIANUINT64(t); 
} 

static int32_t _endian(int32_t t) { 
    return ENDIANULONG(t); 
} 

static uint32_t _endian(uint32_t t) { 
    return ENDIANULONG(t); 
} 

static int16_t _endian(int16_t t) { 
    return ENDIANUSHORT(t); 
} 

static uint16_t _endian(uint16_t t) { 
    return ENDIANUSHORT(t); 
} 

static int8_t _endian(int8_t t) { 
    return t; 
} 

static uint8_t _endian(uint8_t t) { 
    return t; 
} 

Jetzt ohne Vorwarnung, aber ich denke, es gibt zwei Nachteile:

1. Die Funktionen Implementierung ist langweilig, überflüssig und inconcise.
2. Vielleicht sind einige Fälle nicht

bedeckt denke ich C++ 14.11 einen eleganten und kurze Implementierungs es zu beenden zur Verfügung stellen kann, haben Sie eine Idee?

Danke.

Answer 1

Sie brauchen nicht C++ 11/14 per se. Was Sie tun müssen, ist

1. Ersetzen Sie diese Makros mit Inline-Funktionen. Das ist nicht nur mehr C++ sy, es erleichtert auch den nächsten Schritt.
2. Machen Sie die Inline-Funktionen static constexpr Mitglieder in einer Traits Klasse. Akzeptieren von size_t der Ganzzahl als Vorlagenparameter.
3. Implementieren Sie die Vorlage in Bezug auf die Merkmalsklasse.

Der Code:

template<std::size_t> struct EndianTraits; 

template<> 
struct EndianTraits<2u> 
{ 
    using type = std::uint16_t; 
#ifdef _BIG_ENDIAN_ 
    constexpr static type ToEndian(type val) { return val; } 
#else 
    constexpr static type ToEndian(type val) { return ((((val)>>8)&0xff) | 
                (((val)<<8)&0xff00))); } 
#endif 
}; 

template<typename T, 
     typename = std::enable_if<std::numeric_limits<T>::is_integer>::type> 
T Endian(T t) { 
    using type = EndianTraits<sizeof(T)>::type; 
    return EndianTraits<sizeof(T)>::ToEndian(static_cast<type>(t)); 
}