Opinie na temat typowania w C++?

Ignorując efektywność, dla prostoty kodu zrobiłbym:

#include <numeric>
#include <vector>
#include <cstring>

uint32_t compute_checksum(const char *data, size_t size) {
    std::vector<uint32_t> intdata(size/sizeof(uint32_t));
    std::memcpy(&intdata[0], data, size);
    return std::accumulate(intdata.begin(), intdata.end(), 0);
}

Podoba mi się również ostatnia odpowiedź litba, ta, która zmienia każdy znak po kolei, z tym, że skoro znak może być podpisany, myślę, że potrzebuje dodatkowej maski: {]}

checksum += ((data[i] && 0xFF) << shift[i % 4]);

Gdy typowanie jest potencjalnym problemem, wolę nie pisać Kalambury, niż próbować robić to bezpiecznie. Jeśli nie tworzysz aliasowanych wskaźników różnych typów, nie musisz się martwić, co kompilator może zrobić z aliasami i ani programista konserwacyjny, który widzi twoje wiele static_casts za pośrednictwem Unii.

Jeśli nie chcesz przydzielić tyle dodatkowej pamięci, to:

uint32_t compute_checksum(const char *data, size_t size) {
    uint32_t total = 0;
    for (size_t i = 0; i < size; i += sizeof(uint32_t)) {
        uint32_t thisone;
        std::memcpy(&thisone, &data[i], sizeof(uint32_t));
        total += thisone;
    }
    return total;
}

Wystarczająca optymalizacja pozbędzie się memcpy i dodatkowej zmiennej uint32_t w całości na gcc i po prostu odczyta wartość całkowitą bez wyrównania, w dowolny najbardziej efektywny sposób na twojej platformie, prosto z tablicy źródłowej. Mam nadzieję, że to samo dotyczy innych "poważnych" kompilatorów. Ale ten kod jest teraz większy niż litb, więc nie ma o nim wiele do powiedzenia poza moim, łatwiej jest przekształcić go w szablon funkcji, który będzie działał równie dobrze z uint64_t, a mój działa jako natywny endian - ness, zamiast wybierać little-endian.

Są moje pięćdziesiąt centów-różne sposoby na to.

#include <iostream>
#include <string>
#include <cstring>

    uint32_t compute_checksum_memcpy(const char *data, size_t size)
    {
        uint32_t checksum = 0;
        for (size_t i = 0; i != size / 4; ++i)
        {
            // memcpy may be slow, unneeded allocation
            uint32_t dest; 
            memcpy(&dest,data+i,4);
            checksum += dest;
        }
        return checksum;
    }

    uint32_t compute_checksum_address_recast(const char *data, size_t size)
    {
        uint32_t checksum = 0;
        for (size_t i = 0; i != size / 4; ++i)
        {
            //classic old type punning
            checksum +=  *(uint32_t*)(data+i);
        }
        return checksum;
    }

    uint32_t compute_checksum_union(const char *data, size_t size)
    {
        uint32_t checksum = 0;
        for (size_t i = 0; i != size / 4; ++i)
        {
            //Syntax hell
            checksum +=  *((union{const char* c;uint32_t* i;}){.c=data+i}).i;
        }
        return checksum;
    }

    // Wrong!
    uint32_t compute_checksum_deref(const char *data, size_t size)
    {
        uint32_t checksum = 0;
        for (size_t i = 0; i != size / 4; ++i)
        {
            checksum +=  *&data[i];
        }
        return checksum;
    }

    // Wrong!
    uint32_t compute_checksum_cast(const char *data, size_t size)
    {
        uint32_t checksum = 0;
        for (size_t i = 0; i != size / 4; ++i)
        {
            checksum +=  *(data+i);
        }
        return checksum;
    }


int main()
{
    const char* data = "ABCDEFGH";
    std::cout << compute_checksum_memcpy(data, 8) << " OK\n";
    std::cout << compute_checksum_address_recast(data, 8) << " OK\n";
    std::cout << compute_checksum_union(data, 8) << " OK\n";
    std::cout << compute_checksum_deref(data, 8) << " Fail\n";
    std::cout << compute_checksum_cast(data, 8) << " Fail\n";
}

Wiem, że ten wątek jest nieaktywny od jakiegoś czasu, ale pomyślałem, że wrzucę prosty ogólny schemat castingu do tego typu rzeczy:

// safely cast between types without breaking strict aliasing rules
template<typename ReturnType, typename OriginalType>
ReturnType Cast( OriginalType Variable )
{
    union
    {
        OriginalType    In;
        ReturnType      Out;
    };

    In = Variable;
    return Out;
}

// example usage
int i = 0x3f800000;
float f = Cast<float>( i );

To wygląda jak przykład z podręcznika przypadków, kiedy używać reinterpret_cast, cokolwiek innego da ci ten sam efekt bez jasności, jaką uzyskasz dzięki użyciu konstrukcji języka do jego oficjalnego użycia.