static bool is_not_valid_check_sum(const uint8_t* rec, size_t rec_len)
{
    if (rec_len < 3)
        return true;

    const uint8_t* sz_end = rec + rec_len - sizeof(uint16_t);
    uint16_t sum = 0;

    for (; rec < sz_end; ++rec)
        sum += *rec;

    return sum != *reinterpret_cast<const uint16_t *>(sz_end);
}

А>    return sum != *reinterpret_cast<const uint16_t *>(sz_end);
А>}
А>

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>


void hex_print(uint8_t *buf, size_t size);

int main()
{

    

    uint8_t buf1[16], buf2[16], buf3[16];
    uint32_t val;
    uint16_t val16;
    
    memset(buf1, 0, sizeof(buf1));
    memset(buf2, 0, sizeof(buf2));
    memset(buf3, 0, sizeof(buf3));

    val = 0x11223344;
    val16 = 0x7799;
        
    *((uint32_t *)&buf1[0]) = val;
    *((uint32_t *)&buf2[2]) = val;
    *((uint32_t *)&buf3[1]) = val;
    
    *((uint16_t *)&buf1[8]) = val16;
    *((uint16_t *)&buf2[10]) = val16;
    *((uint16_t *)&buf3[9]) = val16;
    
    
    printf("buf1[0] = <%#X>, buf2[2] = <%#X>, buf3[1] = <%#X>\n",
        *((uint32_t *)&buf1[0]),
        *((uint32_t *)&buf2[2]),
        *((uint32_t *)&buf3[1])
    );
    
    printf("buf1[8] = <%#X>, buf2[10] = <%#X>, buf3[9] = <%#X>\n",
        *((uint16_t *)&buf1[8]),
        *((uint16_t *)&buf2[10]),
        *((uint16_t *)&buf3[9])
    );

    for(int i = 0; i < 16; i++){
        printf("%02i|", i);
    }
    printf("\n");

    hex_print(buf1, 16);
    hex_print(buf2, 16);
    hex_print(buf3, 16);
    
    return 0;
}

void hex_print(uint8_t *buf, size_t size)
{
    while(size-- > 0){
        printf("%02X ", *(buf++));
    }
    printf("\n");
}

А>>    return sum != *reinterpret_cast<const uint16_t *>(sz_end);
А>>}
А>>

uint16_t valid_sum;
memcpy(&valid_sum, sz_end, sizeof(valid_sum));
return sum != valid_sum;

А>uint16_t valid_sum;
А>memcpy(&valid_sum, sz_end, sizeof(valid_sum));
А>return sum != valid_sum;
А>

#include <stdint.h>

#define SET_BUF8_VAL16(BUF_UINT8T__, VAL_UINT16T__) \
    { \
        (BUF_UINT8T__)[0] = ((uint8_t *)&(VAL_UINT16T__))[0]; \
        (BUF_UINT8T__)[1] = ((uint8_t *)&(VAL_UINT16T__))[1]; \
    }

#define SET_VAL16_BUF8(VAL_UINT16T__, BUF_UINT8T__) \
    { \
        ((uint8_t *)&(VAL_UINT16T__))[0] = (BUF_UINT8T__)[0]; \
        ((uint8_t *)&(VAL_UINT16T__))[1] = (BUF_UINT8T__)[1]; \
    }
#define SET_BUF8_VAL32(BUF_UINT8T__, VAL_UINT32T__) \
    { \
        (BUF_UINT8T__)[0] = ((uint8_t *)&(VAL_UINT32T__))[0]; \
        (BUF_UINT8T__)[1] = ((uint8_t *)&(VAL_UINT32T__))[1]; \
        (BUF_UINT8T__)[2] = ((uint8_t *)&(VAL_UINT32T__))[2]; \
        (BUF_UINT8T__)[3] = ((uint8_t *)&(VAL_UINT32T__))[3]; \
    }

#define SET_VAL32_BUF8(VAL_UINT32T__, BUF_UINT8T__) \
    { \
        ((uint8_t *)&(VAL_UINT32T__))[0] = (BUF_UINT8T__)[0]; \
        ((uint8_t *)&(VAL_UINT32T__))[1] = (BUF_UINT8T__)[1]; \
        ((uint8_t *)&(VAL_UINT32T__))[2] = (BUF_UINT8T__)[2]; \
        ((uint8_t *)&(VAL_UINT32T__))[3] = (BUF_UINT8T__)[3]; \
    }

uint16_t valid_sum = sz_end | (sz_end << 8);
return sum != valid_sum;

#include <vector>
typedef std::vector<uint8_t> BufferType;
typedef uint32_t CrcType; // обязательно беззнаковый, иначе получим вопросы знакорасширения типов.

CrcType Crc8Mod2CheckSum::calc(BufferType& rBuf, bool crc_included_fl)
{
    CrcType cs = 0xFF;

    if (crc_included_fl){
        BufferType::iterator it_end = rBuf.end() - getCrcLen();
    }
    
    for (BufferType::iterator it = rBuf.begin(); it != it_end; ++it){
        cs ^= *it;
    }

    cs &= 0xFF;

    return cs;
}

uint32_t GetLong(BufferType::iterator& it)
{
    uint32_t retval = 0;

    ///\bug проверить валидность итератора
    for (int shift = 24; shift >= 0; shift -= 8){
        retval |= *it << shift;
        ++it;
    }

    return __le32_to_cpu(retval);
}

struct {
  unsigned some_number;
  Foo foo;
} data;

struct Foo {
  unsigned SomeData;
};

struct DataBuf {
  unsigned char Byte;
  Foo foo;
};