2 baytı işaretli bir 16 bit tam sayıya dönüştürmenin doğru yolu nedir?

Gelen bu cevap , Zwol bu iddiayı yaptı:

İki bayt veriyi harici bir kaynaktan 16 bit işaretli tam sayıya dönüştürmenin doğru yolu aşağıdaki gibi yardımcı işlevlerdir:

#include <stdint.h>

int16_t be16_to_cpu_signed(const uint8_t data[static 2]) {
    uint32_t val = (((uint32_t)data[0]) << 8) | 
                   (((uint32_t)data[1]) << 0);
    return ((int32_t) val) - 0x10000u;
}

int16_t le16_to_cpu_signed(const uint8_t data[static 2]) {
    uint32_t val = (((uint32_t)data[0]) << 0) | 
                   (((uint32_t)data[1]) << 8);
    return ((int32_t) val) - 0x10000u;
}

Yukarıdaki işlevlerden hangisinin uygun olduğu, dizinin küçük bir endian mı yoksa büyük bir endian temsili içeriğine mi bağlıdır. Endian neden merak ediyorum, burada söz konu değil Zwol toplayıp çıkarmadan 0x10000ugelen uint32_tdeğere dönüştürülür int32_t.

Neden doğru yol bu ?

Dönüş türüne dönüştürürken uygulama tanımlı davranışı nasıl önler?

2'nin tamamlayıcı temsilini varsayabildiğiniz için, bu daha basit yayın nasıl başarısız olur: return (uint16_t)val;

Bu saf çözümün nesi yanlış:

int16_t le16_to_cpu_signed(const uint8_t data[static 2]) {
    return (uint16_t)data[0] | ((uint16_t)data[1] << 8);
}

Eğer int16-bit daha sonra ifade değeri eğer sürüm uygulama tanımlı davranışları dayanır returnifadesi için aralık dışında int16_t.

Ancak ilk versiyonun da benzer bir sorunu var; örneğin int32_t, bir typedef ise intve girdi baytlarının her ikisi de 0xFFise, return ifadesindeki çıkarma sonucu, UINT_MAXdönüştürüldüğünde uygulama tanımlı davranışa neden olur int16_t.

İMHO'ya verdiğiniz cevabın birkaç önemli sorunu var.

Bu bilgiçlikle doğru olmalı ve normal 2'nin tamamlayıcısı yerine işaret biti veya 1'in tamamlayıcı gösterimlerini kullanan platformlarda da çalışmalıdır . Giriş baytlarının 2'nin tamamlayıcısı içinde olduğu varsayılır.

int le16_to_cpu_signed(const uint8_t data[static 2]) {
    unsigned value = data[0] | ((unsigned)data[1] << 8);
    if (value & 0x8000)
        return -(int)(~value) - 1;
    else
        return value;
}

Şube nedeniyle, diğer seçeneklerden daha pahalı olacaktır.

Bunun başardığı şey, temsilin platformdaki temsil ile nasıl intilişkili olduğu konusunda herhangi bir varsayımdan kaçınmasıdır unsigned. intHedef türüne sığacak herhangi bir sayının aritmetik değerini korumak için oyuncu kadrosu gereklidir. Ters çevirme, 16 bitlik sayının üst bitinin sıfır olmasını sağladığından değer sığar. Daha sonra -1'in tekli ve çıkarılması, 2'nin tamamlayıcı olumsuzlaması için olağan kuralı uygular. Platforma bağlı olarak , hedef üzerindeki tipe INT16_MINuymazsa yine de taşabilir int, bu durumda longkullanılmalıdır.

Sorudaki orijinal versiyonun farkı dönüş zamanında gelir. Orijinal her zaman çıkarılır 0x10000ve 2'nin tamamlayıcısı, imzalı taşmanın onu int16_taralığa ifsarmasına izin verirken , bu sürümde imzalı sarmalamayı ( tanımsız olan ) önleyen açıktır .

Şimdi pratikte, bugün kullanılan neredeyse tüm platformlar 2'nin tamamlayıcı temsilini kullanmaktadır. Aslında, platformun stdint.htanımlayan standart uyumlu olması durumunda int32_t, bunun için 2'nin tamamlayıcısını kullanması gerekir . Bu yaklaşımın bazen kullanışlı olduğu yerlerde, tamsayı veri türlerine sahip olmayan bazı kodlama dillerinde kullanılır - yukarıda yüzen işlemler için gösterilen işlemleri değiştirebilirsiniz ve doğru sonucu verecektir.

Başka bir yöntem - kullanma union:

union B2I16
{
   int16_t i;
   byte    b[2];
};

Programda:

...
B2I16 conv;

conv.b[0] = first_byte;
conv.b[1] = second_byte;
int16_t result = conv.i;

first_byteve second_byteküçük veya büyük endian modeline göre değiştirilebilir. Bu yöntem daha iyi değil, alternatiflerden biridir.

Aritmetik işleçler kaydırılır ve bitsel olarak veya ifade olarak (uint16_t)data[0] | ((uint16_t)data[1] << 8)daha küçük türlerde çalışmaz int, bu nedenle bu uint16_tdeğerler yükselir int(veya unsignedif sizeof(uint16_t) == sizeof(int)). Yine de, doğru cevabı vermelidir, çünkü sadece düşük 2 bayt değeri içerir.

Big-endian'dan little-endian dönüşümüne (little-endian CPU varsayalım) başka pedantically doğru sürüm:

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

int16_t be16_to_cpu_signed(const uint8_t data[2]) {
    int16_t r;
    memcpy(&r, data, sizeof r);
    return __builtin_bswap16(r);
}

memcpytemsilini kopyalamak için kullanılır int16_tve bunun standart uyumlu bir yoludur. Bu sürüm ayrıca 1 talimata da derlenmiştir movbe, bkz. Montaj .

Yalnızca taşınabilir ve iyi tanımlanmış davranışlara dayanan başka bir sürüm (başlık #include <endian.h>standart değil, kod):

#include <endian.h>
#include <stdint.h>
#include <string.h>

static inline void swap(uint8_t* a, uint8_t* b) {
    uint8_t t = *a;
    *a = *b;
    *b = t;
}
static inline void reverse(uint8_t* data, int data_len) {
    for(int i = 0, j = data_len / 2; i < j; ++i)
        swap(data + i, data + data_len - 1 - i);
}

int16_t be16_to_cpu_signed(const uint8_t data[2]) {
    int16_t r;
#if __BYTE_ORDER == __LITTLE_ENDIAN
    uint8_t data2[sizeof r];
    memcpy(data2, data, sizeof data2);
    reverse(data2, sizeof data2);
    memcpy(&r, data2, sizeof r);
#else
    memcpy(&r, data, sizeof r);
#endif
    return r;
}

Little-endian versiyonu tek bir movbetalimatla derlenir clang, gccversiyon daha az optimumdur, bkz. Montaj .

Tüm katılımcılara cevapları için teşekkür etmek istiyorum. Kolektif eserlerin kaygıları şöyledir:

1. Cı standardına uygun olarak, 7.20.1.1 Tam genişlikli tamsayı türleri : türleri uint8_t, int16_tve uint16_ttemsili gerçek bit yani belirtilen sırayla, dizideki açıkça, herhangi bir dolgu bitleri olmadan 2 bayt bu ikinin tümleyici temsil kullanmalıdır işlev adları.
2. işaretsiz 16 bit değerini (unsigned)data[0] | ((unsigned)data[1] << 8)(küçük endian sürümü için) hesaplamak tek bir komutu derler ve işaretsiz 16 bitlik bir değer verir.
3. C Standardı 6.3.1.3 İmzalı ve imzasız tamsayılara göre : bir tür değerinin uint16_tişaretli türe dönüştürülmesi, değer int16_thedef türünde değilse uygulama tanımlı davranışa sahiptir. Temsili kesin olarak tanımlanmış tipler için özel bir hüküm yoktur.
4. bu uygulama tanımlı davranışı önlemek için, imzasız değerin büyük olup olmadığını test edebilir INT_MAXve çıkararak karşılık gelen işaretli değeri hesaplayabilirsiniz 0x10000. Bunu zwol tarafından önerildiği gibi tüm değerler için yapmak int16_t, aynı uygulama tanımlı davranışa sahip aralığın dışında değerler üretebilir .
5. 0x8000bit için test yapılması derleyicilerin verimsiz kod üretmesine neden olur.
6. uygulama tanımlı davranışı olmadan daha verimli bir dönüşüm , sendika aracılığıyla kurnaz tip kullanır , ancak bu yaklaşımın tanımlanmasına ilişkin tartışma, C Standardı Komite düzeyinde bile açıktır.
7. türü Cinaslar portably gerçekleştirilir kullanılarak davranışı tarif ile olabilir memcpy.

Noktaları 2 ve 7 bir araya burada, taşınabilir ve tam olarak tanımlanmış bir çözüm her iki tek bir talimat verimli derlenir gcc ve clang :

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

int16_t be16_to_cpu_signed(const uint8_t data[2]) {
    int16_t r;
    uint16_t u = (unsigned)data[1] | ((unsigned)data[0] << 8);
    memcpy(&r, &u, sizeof r);
    return r;
}

int16_t le16_to_cpu_signed(const uint8_t data[2]) {
    int16_t r;
    uint16_t u = (unsigned)data[0] | ((unsigned)data[1] << 8);
    memcpy(&r, &u, sizeof r);
    return r;
}

64 bitlik Montaj :

be16_to_cpu_signed(unsigned char const*):
        movbe   ax, WORD PTR [rdi]
        ret
le16_to_cpu_signed(unsigned char const*):
        movzx   eax, WORD PTR [rdi]
        ret