Filter Typnamen in C++

Question

Dies ist mein Konverter zu Byte-Array (Vektor).

template<typename T> 
void put(T value) { 
    int size = sizeof(value); 

    uint8_t *array; 
    array = reinterpret_cast<uint8_t *>(&value); 

    if (littleEndian) { 
     for (int i = 0; i < size; i++) { 
      arr.push_back(array[i]); 
     } 
    } else { 
     for (int i = size - 1; i >= 0; i--) { 
      arr.push_back(array[i]); 
     } 
    } 
} 

Wie Sie sehen können, akzeptiert diese Funktion alle Variablentypen. Ist es möglich, Typnamen zu filtern? Z.B. Ich möchte nur uint8_t, int8_t, uint16_t, int16_t etc. + float and double too zulassen? Ich möchte nicht 10 if Aussagen machen, weil es nicht sauber aussieht.

Answer 1

Sie können dies mit std::is_integral und SFINAE tun. Dadurch wird die Vorlage aus der Betrachtung entfernt, wenn der Typ kein Integer-Typ ist. Es wäre so etwas wie

template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr> 
void put(T value) 
{ 
    // code 
} 

Live Example

aussehen Wenn Sie stattdessen zulassen wollen, dass alle integral und Floating-Point-Typen, dann können Sie std::is_arithmetic verwenden wie

template<typename T, typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr> 
void put(T value) 
{ 
    // code 
} 

Answer 2

Es scheint, dass Sie eine Funktion benötigen, das akzeptiere nur alle integralen Typen.

Es gibt eine vorhandene Typeigenschaft für die <type_traits> Kopfzeile mit der Bezeichnung std::is_integral. Sie können es mit std::enable_if verwenden, um die erwarteten Einschränkung zu produzieren:

template<typename T, std::enable_if_t<std::is_integral<T>::value, int> = 0> 
void put(T value) { 
    constexpr int size = sizeof(value); 

    uint8_t *array; 
    array = reinterpret_cast<uint8_t *>(&value); 

    if (littleEndian) { 
     for (int i = 0; i < size; i++) { 
      arr.push_back(array[i]); 
     } 
    } else { 
     for (int i = size - 1; i >= 0; i--) { 
      arr.push_back(array[i]); 
     } 
    } 
} 

Ihre Funktion ist jetzt nicht aufrufbar mit nicht ganzzahligen Typen.

Beachten Sie, dass der Compiler es auch versuchen wird, wenn eine andere Überladung der Funktion auftritt. Das bedeutet, dass der Compiler die entsprechende Überladung auswählt, wenn Sie eine andere Funktion haben, die beliebige Gleitkommatypen akzeptiert.