Мнения о каламбуре в C ++?

Что касается стандарта C ++, ответ litb таков: полностью правильный и самый портативный. Преобразование const char *data в const uint3_t *, будь то преобразование в стиле C, static_cast или reinterpret_cast, нарушает строгие правила псевдонима (см. Общие сведения о строгом псевдониме). Если вы компилируете с полной оптимизацией, есть большая вероятность, что код будет работать неправильно.

Преобразование через объединение (например, litb my_reint), вероятно, является лучшим решением, хотя технически оно нарушает правило, согласно которому, если вы пишете в объединение через один член и читаете его через другой, это приводит к неопределенному поведению. Однако практически все компиляторы это поддерживают, и это дает ожидаемый результат. Если вы абсолютно хотите соответствовать стандарту на 100%, используйте метод битового сдвига. В противном случае я бы рекомендовал использовать кастинг через объединение, что, вероятно, даст вам лучшую производительность.

Не обращая внимания на эффективность, для простоты кода я бы сделал:

#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);
}

Мне также нравится последний ответ litb, который по очереди сдвигает каждый символ, за исключением того, что, поскольку char может быть подписан, я думаю, что ему нужна дополнительная маска:

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

Когда каламбур является потенциальной проблемой, я предпочитаю не печатать каламбур, а не пытаться сделать это безопасно. Если вы в первую очередь не создаете указатели с псевдонимами отдельных типов, вам не нужно беспокоиться о том, что компилятор может сделать с псевдонимами, как и программист обслуживания, который видит ваши несколько static_cast через объединение.

Если вы не хотите выделять столько дополнительной памяти, то:

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;
}

Достаточная оптимизация позволит полностью избавиться от memcpy и дополнительной переменной uint32_t в gcc, а просто прочитать невыровненное целочисленное значение любым наиболее эффективным способом, который есть на вашей платформе, прямо из исходного массива. Я надеюсь, что то же самое можно сказать и о других «серьезных» компиляторах. Но этот код теперь больше, чем у litb, поэтому о нем особо нечего сказать, кроме моего, его проще превратить в шаблон функции, который будет работать так же хорошо с uint64_t, а мой работает как нативный порядок байтов, а не выбирает мало -энди.

Это, конечно, не полностью переносимо. Предполагается, что представление хранилища символов sizeof (uint32_t) соответствует представлению хранилища uin32_t так, как мы хотим. Это подразумевается вопросом, поскольку в нем говорится, что одно можно «рассматривать как» другое. Порядок байтов, является ли char 8-битным и использует ли uint32_t все биты в своем представлении хранилища, очевидно, может вмешиваться, но вопрос подразумевает, что они этого не сделают.

Есть мои пятьдесят центов - разные способы это сделать.

#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";
}

Я знаю, что эта ветка какое-то время была неактивной, но я подумал, что опубликую простую общую процедуру кастинга для такого рода вещей:

// 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 );

Надеюсь, это кому-то поможет!