ผู้ประกอบการบิตมีประโยชน์อย่างไร? [ปิด]

ภาษาการเขียนโปรแกรมมักจะมาพร้อมกับตัวดำเนินการบิตต่าง ๆ (เช่นการเปลี่ยนบิตซ้าย - ขวาและบิต, ค่าบิตและ AND, หรือ, แฮคเกอร์ ... ) สิ่งเหล่านี้ไม่ได้ถูกใช้อย่างมาก แต่อย่างน้อยประสบการณ์ของฉันก็เช่นกัน บางครั้งพวกเขาจะใช้ในการเขียนโปรแกรมความท้าทายหรือคำถามสัมภาษณ์หรือวิธีแก้ปัญหาต้องใช้พวกเขาเช่น:

• โดยไม่ต้องใช้ตัวดำเนินการเท่าเทียมกันใด ๆ สร้างฟังก์ชันที่ส่งคืนtrueเมื่อสองค่าเท่ากัน
• โดยไม่ใช้ตัวแปรตัวที่สามให้สลับค่าของตัวแปรสองตัว

สิ่งเหล่านี้อีกครั้งอาจมีการใช้งานจริงไม่กี่แห่ง ฉันเดาว่าพวกเขาควรจะเร็วขึ้นเพราะพวกเขาจัดการหน่วยความจำโดยตรงในระดับต่ำ

เหตุใดจึงพบเช่นนี้ในภาษาการเขียนโปรแกรมส่วนใหญ่ กรณีใช้งานจริงใด ๆ

ไม่พวกมันมีแอพพลิเคชั่นมากมายในโลกแห่งความเป็นจริงและเป็นการใช้งานพื้นฐานบนคอมพิวเตอร์

พวกเขาใช้สำหรับ

• การเล่นกลบล็อกของไบต์ที่ไม่สอดคล้องกับชนิดข้อมูลภาษาการเขียนโปรแกรม
• สลับการเข้ารหัสไปมาจากใหญ่ไปน้อย endian
• บรรจุข้อมูล 6 บิต 4 บิตเป็น 3 ไบต์สำหรับการเชื่อมต่อแบบอนุกรมหรือ usb
• รูปแบบภาพจำนวนมากมีจำนวนบิตที่แตกต่างกันที่กำหนดให้กับแต่ละช่องสี
• สิ่งใดที่เกี่ยวข้องกับหมุด IO ในแอปพลิเคชันแบบฝัง
• การบีบอัดข้อมูลซึ่งมักจะไม่มีข้อมูลพอดีกับขอบเขต 8 บิตที่ดี \
• อัลกอริทึมการแฮช CRC หรือการตรวจสอบความสมบูรณ์ของข้อมูลอื่น ๆ
• การเข้ารหัสลับ
• การสร้างหมายเลข psuedorandom
• การจู่โจม 5 ใช้ bitor XOR ระหว่างโวลุ่มเพื่อคำนวณพาริตี
• ตันมากขึ้น

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

เพราะมันเป็นปฏิบัติการพื้นฐาน

ในแนวความคิดเดียวกันคุณสามารถยืนยันว่าการเพิ่มนั้นมีการใช้งานจริงเพียงไม่กี่อย่างเนื่องจากมันสามารถแทนที่ได้อย่างสมบูรณ์ด้วยการลบ (และการปฏิเสธ) และการคูณ แต่เรายังคงเพิ่มเพราะมันเป็นการดำเนินงานขั้นพื้นฐาน

และอย่าคิดว่าสักครู่ที่เพียงเพราะคุณไม่ได้เห็นความต้องการการดำเนินงานระดับบิตมากไม่ได้หมายความว่าพวกเขาไม่ได้ใช้บ่อยนัก อันที่จริงฉันใช้ bitwise ops ในเกือบทุกภาษาที่ฉันเคยใช้กับสิ่งต่าง ๆ เช่น bit masking

ด้านบนของหัวของฉันฉันใช้ bitwise ops สำหรับการประมวลผลภาพ bitfields และค่าสถานะการประมวลผลข้อความ (เช่นตัวละครทุกตัวของคลาสเฉพาะมักจะใช้รูปแบบบิตทั่วไป) การเข้ารหัสและถอดรหัสข้อมูลต่อเนื่องถอดรหัส VM หรือ CPU opcodes และอื่น ๆ งานเหล่านี้ส่วนใหญ่จะต้องใช้การดำเนินงานที่ซับซ้อนมากขึ้นหลายครั้งในการปฏิบัติงานให้น้อยลงหรือมีความสามารถในการอ่านต่ำ

ตัวอย่างเช่น:

// Given a 30-bit RGB color value as a 32-bit int
// A lot of image sensors spit out 10- or 12-bit data
// and some LVDS panels have a 10- or 12-bit format
b = (color & 0x000003ff);
g = (color & 0x000ffc00) >> 10;
r = (color & 0x3ff00000) >> 20;

// Going the other way:
color = ((r << 20) & 0x3ff00000) | ((g << 10) & 0x000ffc00) | (b & 0x000003ff);

การถอดรหัสคำสั่ง CPU สำหรับซีพียูชนิด RISC (เช่นเมื่อจำลองแพลตฟอร์มอื่น) จำเป็นต้องแยกส่วนที่มีค่ามากดังกล่าวข้างต้น บางครั้งการดำเนินการเหล่านี้ด้วยการคูณและการหารและโมดูโล ฯลฯ อาจช้ากว่าสิบเท่าของบิตทรานส์โอเปอเรเตอร์ที่เท่ากัน

ตัวอย่างทั่วไปคือการแยกแต่ละสีจากค่า RGB 24 บิตและย้อนกลับ

แก้ไข: จากhttp://www.docjar.com/html/api/java/awt/Color.java.html

    value =  ((int)(frgbvalue[2]*255 + 0.5))    |
                (((int)(frgbvalue[1]*255 + 0.5)) << 8 )  |
                (((int)(frgbvalue[0]*255 + 0.5)) << 16 ) |
                (((int)(falpha*255 + 0.5)) << 24 );

นี่คือตัวอย่างโลกจริงที่คุณจะพบใน Quake 3, Quake 4 Doom III ทุกเกมที่ใช้เครื่องยนต์ไตรมาสที่ 3

float Q_rsqrt( float number )
{
        long i;
        float x2, y;
        const float threehalfs = 1.5F;

        x2 = number * 0.5F;
        y  = number;
        i  = * ( long * ) &y;                       // evil floating point bit level hacking [sic]
        i  = 0x5f3759df - ( i >> 1 );               // what the fuck? [sic]
        y  = * ( float * ) &i;
        y  = y * ( threehalfs - ( x2 * y * y ) );   // 1st iteration
//    y  = y * ( threehalfs - ( x2 * y * y ) );   // 2nd iteration, this can be removed

        return y;
}

(เพื่อให้เข้าใจรหัสที่คุณต้องเข้าใจวิธีการจัดเก็บหมายเลขจุดลอยตัวฉันไม่สามารถอธิบายรายละเอียดได้อย่างแน่นอน)

ในแง่ของการใช้งานนอกเสียจากคุณจะอยู่ในสาขาที่ต้องการการเปลี่ยนบิตเช่นเครือข่ายหรือกราฟิกคุณอาจพบว่าวัตถุประสงค์ของพวกเขานั้นเป็นเรื่องทางวิชาการเล็กน้อย แต่ก็ยังน่าสนใจ (สำหรับฉันอย่างน้อย)

การเลื่อนเร็วกว่าการคูณหรือหารด้วยกำลังสอง ตัวอย่างเช่น << = 2 คูณ a ด้วย 4 ตรงกันข้าม a >> = 2 หาร a ด้วยสี่ หนึ่งยังสามารถบิตข้อมูลปังออกไปยังอุปกรณ์ที่ใช้ตัวดำเนินการ bit-wise ตัวอย่างเช่นเราสามารถส่งข้อมูลอนุกรม N สตรีมออกจากพอร์ต N Pin โดยใช้การดำเนินการ shift, xor และ "และ" ภายใน N ลูป สิ่งใดก็ตามที่สามารถทำได้ในตรรกะดิจิทัลสามารถทำได้บนซอฟต์แวร์และในทางกลับกัน

นานมาแล้วผู้ประกอบการบิตมีประโยชน์ วันนี้พวกเขามีน้อย โอ้พวกเขาไม่ได้ไร้ประโยชน์อย่างสิ้นเชิง แต่จะได้รับเป็นเวลานานตั้งแต่ผมเคยเห็นหนึ่งที่ใช้ที่ควรจะนำมาใช้

ในปี 1977 ฉันเป็นโปรแกรมเมอร์ภาษาแอสเซมบลี ฉันเชื่อว่าแอสเซมเบลอร์เป็นภาษาเดียวเท่านั้น ผมเป็นบางอย่างที่เหมือนภาษาปาสคาลได้สำหรับ weenies วิชาการที่ไม่เคยได้รับอะไรจริงทำ

จากนั้นฉันก็อ่าน "ภาษาการเขียนโปรแกรม C" โดย Kernighan และ Ritchie มันเปลี่ยนความคิดของฉันอย่างสมบูรณ์ เหตุผล? มันมีตัวดำเนินการบิต! มันเป็นภาษาแอสเซมบลี! มันเพิ่งมีรูปแบบที่แตกต่างกัน

ย้อนกลับไปในสมัยนั้นฉันไม่สามารถนึกถึงการเขียนรหัสโดยไม่ต้อง ands, ors, กะและหมุน ทุกวันนี้ฉันแทบไม่เคยใช้เลย

ดังนั้นคำตอบสั้น ๆ สำหรับคำถามของคุณคือ: "ไม่มีอะไร" แต่นั่นไม่ยุติธรรมเลย ดังนั้นคำตอบอีกต่อไปคือ: "ไม่มีอะไรเป็นส่วนใหญ่"

การเข้ารหัสลับ

ฉันขอแนะนำให้ดูตัวอย่างข้อมูลขนาดเล็กมากจากอัลกอริทึมการเข้ารหัส DES :

temp = ((left >>> 1) ^ right) & 0x55555555; right ^= temp; left ^= (temp << 1);
temp = ((right >>> 8) ^ left) & 0x00ff00ff; left ^= temp; right ^= (temp << 8);
temp = ((right >>> 2) ^ left) & 0x33333333; left ^= temp; right ^= (temp << 2);
temp = ((left >>> 16) ^ right) & 0x0000ffff; right ^= temp; left ^= (temp << 16);
temp = ((left >>> 4) ^ right) & 0x0f0f0f0f; right ^= temp; left ^= (temp << 4);

คำตอบที่ดีมากดังนั้นฉันจะไม่ใช้ซ้ำเหล่านั้น

ฉันใช้รหัสที่ได้รับการจัดการค่อนข้างมาก (C # / .Net) และไม่มีอะไรเกี่ยวข้องกับการประหยัดพื้นที่ประสิทธิภาพสูงหรืออัลกอริทึมการเปลี่ยนบิตที่ชาญฉลาด บางครั้งตรรกะบางอย่างก็เหมาะสมกับการจัดเก็บข้อมูลด้วยวิธีนี้ ฉันมักจะใช้พวกเขาเมื่อฉันมี enum แต่กรณีสามารถใช้พร้อมกันหลายค่าจาก enum นั้น ฉันไม่สามารถโพสต์ตัวอย่างโค้ดจากที่ทำงานได้ แต่ Google ด่วนสำหรับ "Flags enum" ("Flags" เป็นวิธี C # ในการกำหนด enum ที่จะใช้ในลักษณะบิต) ให้ตัวอย่างที่ดีนี้: http: // www.dotnetperls.com/enum-flags

นอกจากนี้ยังมีการคำนวณแบบขนานบิต หากข้อมูลของคุณมีเพียง 1 และ 0 คุณสามารถบรรจุ 64 รายการในคำที่มีความยาวไม่ได้ลงนามและรับการดำเนินการแบบคู่ขนาน 64way ข้อมูลทางพันธุกรรมคือสองบิต (แสดงถึงการเข้ารหัส AGCT ของ DNA) และถ้าคุณสามารถทำการคำนวณต่าง ๆ ในแบบคู่ขนานบิตคุณสามารถทำได้มากกว่าถ้าคุณไม่ทำ ไม่ต้องพูดถึงความหนาแน่นของข้อมูลในหน่วยความจำหากหน่วยความจำหรือความจุดิสก์หรือแบนด์วิดธ์การสื่อสารมี จำกัด หมายความว่าควรพิจารณาการบีบอัด / คลายการบีบอัด แม้แต่จำนวนเต็มต่ำ precison ซึ่งปรากฏในพื้นที่เช่นการประมวลผลภาพสามารถใช้ประโยชน์จากการคำนวณแบบขนานบิตหากิน มันเป็นศิลปะทั้งแก่ตัวเอง

ทำไมพวกเขาพบ

อาจเป็นเพราะพวกเขาสอดคล้องกับคำแนะนำการประกอบและบางครั้งพวกเขาก็มีประโยชน์สำหรับสิ่งต่าง ๆ ในภาษาระดับสูงกว่า สิ่งเดียวกันนำไปใช้กับหวั่นGOTOซึ่งสอดคล้องกับJMPคำแนะนำการชุมนุม

พวกเขาใช้อะไร?

จริงๆแล้วมีการใช้งานหลายอย่างเพื่อตั้งชื่อดังนั้นฉันจะเพิ่งให้การใช้งานล่าสุด ฉันทำงานมากด้วยชุดประกอบ 6502 และฉันกำลังทำงานกับแอปพลิเคชันขนาดเล็กที่แปลงที่อยู่หน่วยความจำค่าเปรียบเทียบค่า ฯลฯ เป็นรหัสที่สามารถใช้สำหรับอุปกรณ์ GameGenie (โดยทั่วไปแล้วเป็นแอปพลิเคชั่นโกงสำหรับ NES) รหัสถูกสร้างโดยการจัดการบิต

โปรแกรมเมอร์หลายคนในทุกวันนี้ใช้กับคอมพิวเตอร์ที่มีหน่วยความจำใกล้หมด

แต่บางส่วนของการใช้งานยังคงโปรแกรมไมโครคอนโทรลเลอร์ขนาดเล็กที่ทุกบิตนับ (เมื่อคุณมี RAM เพียง 1k หรือน้อยกว่า) และตัวดำเนินการบิตเตอร์ช่วยให้โปรแกรมเมอร์ใช้บิตเหล่านั้นครั้งละครั้งแทนที่จะเสียการเขียนโปรแกรมที่ใหญ่กว่า เอนทิตีที่เป็นนามธรรมกว่าอาจจำเป็นต้องมีสถานะที่ต้องการโดยอัลกอริทึม IO บนอุปกรณ์เหล่านั้นอาจจำเป็นต้องมีการอ่านหรือควบคุมบนฐานบิต

"โลกแห่งความจริง" นั้นมีไมโครคอนโทรลเลอร์ขนาดเล็กเหล่านั้นมากกว่าเซิร์ฟเวอร์หรือพีซี

สำหรับประเภท CS ในเชิงทฤษฎีล้วน ๆ เครื่องจักรทัวริงล้วนเกี่ยวกับบิตของสถานะ

มีการใช้งานโอเปอเรเตอร์ที่เป็นไปได้อีกมากมาย

ตัวดำเนินการระดับบิตยังสามารถช่วยให้โค้ดของคุณอ่านง่ายขึ้น พิจารณาการประกาศฟังก์ชันต่อไปนี้ ....

int  myFunc (bool, bool, bool, bool, bool, bool, bool, bool);

...

myFunc (false, true, false, false, false, true, true, false);

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

/* More descriptive names than MY_FLAGx would be better */
#define MY_FLAG1    0x0001
#define MY_FLAG2    0x0002
#define MY_FLAG3    0x0004
#define MY_FLAG4    0x0008
#define MY_FLAG5    0x0010
#define MY_FLAG6    0x0020
#define MY_FLAG7    0x0040
#define MY_FLAG8    0x0080

int  myFunc (unsigned myFlags);

...

myFunc (MY_FLAG2 | MY_FLAG6 | MY_FLAG7);

ด้วยชื่อแฟล็กที่สื่อความหมายมากกว่านั้นจะสามารถอ่านได้มากขึ้น

หากคุณรู้อะไรเกี่ยวกับUnicodeคุณอาจคุ้นเคยกับ UTF-8 มันใช้การทดสอบบิตพวงกะและมาสก์เพื่อแพ็ครหัส 20 บิตเป็น 1 ถึง 4 ไบต์

ฉันไม่ได้ใช้บ่อย แต่บางครั้งก็มีประโยชน์ การจัดการ Enumอยู่ในใจ

ตัวอย่าง:

enum DrawBorder{None = 0, Left = 1, Top = 2, Right = 4, Bottom = 8}

DrawBorder drawBorder = DrawBorder.Left | DrawBorder.Right;//Draw right & left border
if(drawBorder & DrawBorder.Left == DrawBorder.Left)
  //Draw the left border
if(drawBorder & DrawBorder.Top == DrawBorder.Top)
  //Draw the top border
//...

ไม่แน่ใจว่ามีการบันทึกการใช้งานนี้หรือไม่:

ฉันเห็นหรือค่อนข้างมากเมื่อทำงานกับรหัสต้นฉบับ illumos (openSolaris) เพื่อลดค่าส่งคืนหลายค่าเป็น 0 หรือ 1 เช่น

int ret = 0;
ret |= some_function(arg, &arg2); // returns 0 or 1
ret |= some_other_function(arg, &arg2); // returns 0 or 1
return ret;