วิธีที่ถูกต้องในการแปลง 2 ไบต์เป็นจำนวนเต็ม 16 บิตที่ลงนามคืออะไร?

ในคำตอบนี้ , zwolทำให้การเรียกร้องนี้:

วิธีที่ถูกต้องในการแปลงข้อมูลสองไบต์จากแหล่งข้อมูลภายนอกให้เป็นจำนวนเต็ม 16 บิตที่มีลายเซ็นคือฟังก์ชันผู้ช่วยเช่นนี้

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

ฟังก์ชันข้างต้นใดที่เหมาะสมขึ้นอยู่กับว่าอาเรย์นั้นประกอบไปด้วย endian เพียงเล็กน้อยหรือการแสดง endian ขนาดใหญ่ endianness ไม่เป็นปัญหาที่คำถามที่นี่ผมกำลังสงสัยว่าทำไมzwolหัก0x10000uจากค่าแปลงuint32_tint32_t

เหตุใดจึงเป็นวิธีที่ถูกต้อง ?

มันจะหลีกเลี่ยงพฤติกรรมที่กำหนดโดยการนำไปปฏิบัติเมื่อแปลงเป็นชนิดส่งคืนได้อย่างไร

เนื่องจากคุณสามารถสันนิษฐานได้ว่าการเป็นตัวแทน 2 นั้นจะทำให้การโยนง่ายขึ้นอย่างไร: return (uint16_t)val;

เกิดอะไรขึ้นกับโซลูชันไร้เดียงสานี้:

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

ถ้าintเป็นแบบ 16 บิตแล้วรุ่นที่คุณอาศัยอยู่กับพฤติกรรมการดำเนินงานที่กำหนดไว้ถ้าค่าของการแสดงออกในที่คำสั่งจะออกช่วงสำหรับreturnint16_t

อย่างไรก็ตามรุ่นแรกยังมีปัญหาที่คล้ายกัน เช่นถ้าint32_tเป็น typedef หาintและไบต์การป้อนข้อมูลทั้งสอง0xFFแล้วผลของการลบในงบผลตอบแทนที่เป็นซึ่งเป็นสาเหตุของพฤติกรรมการดำเนินงานที่กำหนดไว้เมื่อแปลงเป็นUINT_MAXint16_t

IMHO คำตอบที่คุณเชื่อมโยงไปมีปัญหาสำคัญหลายประการ

นี้ควรจะอวดที่ถูกต้องและการทำงานยังบนแพลตฟอร์มที่ใช้บิตเครื่องหมายหรือ1 ส่วนเติมเต็มการแสดง, แทนที่จะเป็น2 ส่วนเติมเต็ม ไบต์อินพุตจะถือว่าเป็นส่วนเสริมของ 2

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

เนื่องจากสาขาจะมีราคาแพงกว่าตัวเลือกอื่น ๆ

สิ่งนี้ประสบความสำเร็จคือมันหลีกเลี่ยงข้อสันนิษฐานใด ๆ ว่าการintเป็นตัวแทนเกี่ยวข้องกับการนำunsignedเสนอบนแพลตฟอร์มอย่างไร intจำเป็นต้องใช้cast เพื่อเก็บค่าเลขคณิตสำหรับหมายเลขใด ๆ ที่จะพอดีกับประเภทเป้าหมาย เนื่องจากการผกผันทำให้จำนวนบิตบนสุดของ 16 บิตเป็นศูนย์ค่าจะพอดี จากนั้นการรวมกันเป็นหนึ่ง-และการลบของ 1 จะใช้กฎปกติสำหรับการปฏิเสธแบบเติมเต็มของ 2 ขึ้นอยู่กับแพลตฟอร์มINT16_MINอาจยังล้นได้หากไม่เหมาะกับintประเภทของเป้าหมายซึ่งlongควรใช้ในกรณีใด

ความแตกต่างของเวอร์ชันต้นฉบับในคำถามนั้นมาจากเวลาที่ส่งคืน ในขณะที่เดิมเพียงแค่ลบออกเสมอ0x10000และ 2 ส่วนเติมเต็มให้ลงนามห่อล้นไปยังint16_tช่วงรุ่นนี้มีความชัดเจนifที่หลีกเลี่ยงการลงนาม wrapover (ซึ่งไม่ได้กำหนด )

ตอนนี้ในทางปฏิบัติเกือบทุกแพลตฟอร์มที่ใช้อยู่ในปัจจุบันใช้ตัวแทนที่สมบูรณ์ของ 2 ในความเป็นจริงหากแพลตฟอร์มมีมาตรฐานstdint.hที่กำหนดไว้int32_tมันจะต้องใช้ส่วนประกอบ 2 ของมัน วิธีการที่สะดวกในบางครั้งวิธีนี้คือภาษาสคริปต์บางตัวที่ไม่มีชนิดข้อมูลจำนวนเต็มเลย - คุณสามารถแก้ไขการดำเนินการที่แสดงด้านบนเพื่อทำการลอยได้และจะให้ผลลัพธ์ที่ถูกต้อง

วิธีอื่น - การใช้union:

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

ในโปรแกรม:

...
B2I16 conv;

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

first_byteและsecond_byteสามารถเปลี่ยนได้ตามรุ่น endian น้อยหรือใหญ่ วิธีนี้ไม่ได้ดีกว่า แต่เป็นหนึ่งในทางเลือก

ตัวดำเนินการทางคณิตศาสตร์ เลื่อนและbitwise- หรือในนิพจน์(uint16_t)data[0] | ((uint16_t)data[1] << 8)ไม่ทำงานกับชนิดที่เล็กกว่าintดังนั้นuint16_tค่าเหล่านั้นจึงถูกเลื่อนระดับเป็นint(หรือunsignedถ้าsizeof(uint16_t) == sizeof(int)) แต่ถึงกระนั้นก็ควรให้คำตอบที่ถูกต้องเนื่องจากเพียง 2 ไบต์ที่ต่ำกว่ามีค่า

อีกเวอร์ชั่นที่ถูกต้องสำหรับการแปลงแบบบิ๊ก - เอนด์ถึงเอนด์ - เอนเดเนี่ยน

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

memcpyใช้เพื่อคัดลอกการแทนค่าint16_tและเป็นวิธีที่เป็นไปตามมาตรฐานในการทำเช่นนั้น รุ่นนี้ยังรวบรวมลงใน 1 คำแนะนำmovbeให้ดูที่การชุมนุม

นี่เป็นอีกเวอร์ชั่นที่ต้องอาศัยการทำงานแบบพกพาและที่กำหนดไว้อย่างดี (ส่วนหัว #include <endian.h>ไม่ได้มาตรฐานรหัสคือ):

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

เวอร์ชั่นเล็ก ๆ ของ endian รวบรวมmovbeคำสั่งเดียวด้วยclang, gccเวอร์ชั่นนั้นน้อยที่สุด, ดูแอสเซมบลี .

ฉันอยากจะขอบคุณผู้มีส่วนร่วมทั้งหมดสำหรับคำตอบของพวกเขา นี่คือสิ่งที่ผลงานโดยรวมกำลังเดือดลงไปที่:

1. เป็นต่อ C มาตรฐาน7.20.1.1 ประเภทจำนวนเต็มแน่นอนความกว้าง : ประเภทuint8_t, int16_tและuint16_tต้องใช้ทั้งสองเป็นตัวแทนที่สมบูรณ์โดยไม่ต้องบิต padding ใด ๆ ดังนั้นบิตที่เกิดขึ้นจริงของการเป็นตัวแทนที่มีอย่างไม่น่าสงสัยเหล่านั้นของ 2 ไบต์ในอาร์เรย์ในการสั่งซื้อที่กำหนดโดย ชื่อฟังก์ชั่น
2. คำนวณค่า 16 บิตที่ไม่ได้ลงนามด้วย (unsigned)data[0] | ((unsigned)data[1] << 8)การคอมไพล์ (สำหรับรุ่น endian น้อย) ไปยังคำสั่งเดียวและให้ค่า 16 บิตที่ไม่ได้ลงนาม
3. ตาม C 6.3.1.3มาตรฐานจำนวนเต็มที่ลงนามและไม่ได้ลงนาม : การแปลงค่าชนิดเป็นประเภทuint16_tที่ลงนามint16_tมีพฤติกรรมการใช้งานที่กำหนดไว้หากค่าไม่ได้อยู่ในช่วงของประเภทปลายทาง ไม่มีการจัดเตรียมพิเศษสำหรับประเภทที่มีการกำหนดการแสดงอย่างแม่นยำ
4. เพื่อหลีกเลี่ยงพฤติกรรมการดำเนินงานที่กำหนดไว้นี้หนึ่งสามารถทดสอบถ้าค่าไม่ได้ลงนามมีขนาดใหญ่กว่าและคำนวณค่าลงนามที่สอดคล้องกันโดยการลบINT_MAX 0x10000การทำเช่นนี้สำหรับค่าทั้งหมดตามที่แนะนำโดยzwolอาจสร้างค่าที่อยู่นอกช่วงที่int16_tมีพฤติกรรมการใช้งานที่กำหนดไว้เหมือนกัน
5. การทดสอบ0x8000บิตจะทำให้คอมไพเลอร์สร้างโค้ดที่ไม่มีประสิทธิภาพ
6. การแปลงที่มีประสิทธิภาพมากขึ้นโดยไม่ใช้พฤติกรรมที่กำหนดไว้ใช้ประเภทการติดตามผ่านทางสหภาพ แต่การอภิปรายเกี่ยวกับความชัดเจนของวิธีการนี้ยังคงเปิดอยู่แม้ในระดับคณะกรรมการของมาตรฐาน C
7. ประเภทเล่นสำนวนสามารถดำเนินการ portably memcpyและมีพฤติกรรมที่กำหนดไว้โดยใช้

การรวมจุดที่ 2 และ 7 นี่คือโซลูชันแบบพกพาและกำหนดอย่างสมบูรณ์ที่รวบรวมได้อย่างมีประสิทธิภาพในคำสั่งเดียวด้วยgccและ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- บิต :

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