The easiest way to convert an arithmetic type to a std::array in C++

Question

I have a function that calculates CRC64 and returns it as uint64_t:

static inline uint64_t crc64(uint64_t crc, const uint8_t *s, size_t l)
{
    const uint8_t * end = s + l;

    for (const uint8_t * p = s; p != end; ++p)
    {
        const uint8_t byte = *p;
        crc = crc64_tab[(uint8_t)crc ^ byte] ^ (crc >> 8);
    }

    return crc;
}

and I'd like to convert the result to std::array<sizeof(uint8_t)> and make it independent of the endianness (little/big endian). Is the there a simple and elegant way to do this in C++?

Is it possible to have a simple template function working for all the arithmetic types like uintN_t?

Do you want little- or big-endian order in the result? And do you want good performance? — rustyx, Sep 03 '18 at 17:52
Related: [Is there any “standard” htonl-like function for 64 bits integers in C++?](https://stackoverflow.com/questions/3022552/is-there-any-standard-htonl-like-function-for-64-bits-integers-in-c) — Not a real meerkat, Sep 03 '18 at 17:55

Swordfish · Accepted Answer · 2018-09-03T17:47:54.703

1

Is it possible to have a simple template function working for all the arithmetic types like uintN_t?

#include <cstddef>
#include <cstdint>
#include <array>

template< typename T >
std::array<std::uint8_t, sizeof(T)> to_array(T value)
{
    std::array<std::uint8_t, sizeof(T)> result;

    for (std::size_t i{ sizeof(T) }; i; --i)
        result[i - 1] = value >> ((sizeof(T) - i) * 8);

    return result;
}

edited Sep 03 '18 at 17:47

answered Sep 03 '18 at 17:32

Swordfish

12,971
3
21
43

Clang does well with this, is there a way to make GCC generate sane code here? E: oh, "update GCC" apparently. But still. Is there something more compatible with say GCC 7.3? – harold Sep 03 '18 at 17:38

score 0 · Answer 2 · answered Sep 04 '18 at 06:26

I think I'd be inclined to invert the dependencies and create the concept of "bytewise_accumulation" of a type.

It seems to generate good code on gcc8:

#include <cstddef>
#include <cstdint>
#include <type_traits>

// general case
template<class T>
struct bytewise_accumulator
{
    template<class Arg, class F, class Acc>
    constexpr decltype(auto) operator()(Arg value, F&& f, Acc acc) const
    {
        for(std::size_t i = 0 ; i < sizeof(T) ; ++i)
        {
            acc = f(acc, std::uint8_t(value));
            value >>= 8;
        }
        return acc;
    }    
};

template<class T>
auto make_bytewise_accumulator(T&&)
{
    return bytewise_accumulator<std::remove_reference_t<std::remove_const_t<T>>>();
}

// overload for c-arrays but others could be provided for std::array, vector, etc
template<class T, std::size_t N>
struct bytewise_accumulator<T[N]>
{
    template<class F, class Acc>
    constexpr decltype(auto) operator()(T(&value)[N], F&& f, Acc acc) const
    {
        for(auto&& x : value)
        {
            auto op = make_bytewise_accumulator(x);
            acc = op(x, f, acc);
        }
        return acc;
    }    
};

template< 
    typename Acc,
    typename T, 
    class F
>
constexpr decltype(auto) bytewise_accumulate(T&& value, F&& f, Acc acc)
{
    auto op = make_bytewise_accumulator(value);
    return op(value, f, acc);
}


// the actual crc function
auto crc64(std::uint64_t crc, std::uint8_t byte) -> std::uint64_t
{
    extern std::uint64_t crc64_tab[256];
    return crc64_tab[(uint8_t)crc ^ byte] ^ (crc >> 8);
}

// compute a crc of a series of objects    
template<class...Ts> 
auto compute_crc64(Ts&&...ts) -> std::uint64_t
{
    auto crc = std::uint64_t(0);
    ((crc = bytewise_accumulate(ts, crc64, crc)), ...);
    return crc;
}

// some tests... 

extern int get_int();
extern void emit(std::uint64_t);

struct Data
{
    int x;
    int y;
    unsigned long z;
    char data[128];
};

// overload bytewise_accumulate for my custom type    
template< 
    typename Acc,
    class F
>
constexpr decltype(auto) bytewise_accumulate(Data const& d, F&& f, Acc acc)
{
    acc = bytewise_accumulate(d.x, f, acc);
    acc = bytewise_accumulate(d.y, f, acc);
    acc = bytewise_accumulate(d.z, f, acc);
    acc = bytewise_accumulate(d.data, f, acc);
    return acc;
}

extern Data const& get_data();

int main()
{
    auto i = get_int();
    auto crc = compute_crc64(i);
    emit(crc);

    emit(compute_crc64(get_data()));
}

The easiest way to convert an arithmetic type to a std::array in C++

2 Answers2