หากเครื่อง 32 บิตสามารถจัดการตัวเลขได้สูงสุด 2 ^ 32 ทำไมฉันสามารถเขียน 1000000000000 (ล้านล้าน) โดยที่เครื่องของฉันหยุดทำงาน

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

อย่างไรก็ตามหมายเลข 2 ³¹ - 1 (2,147,483,647) นั้นไม่ใหญ่เท่ากับหมายเลข 1 ล้านล้าน (1,000,000,000,000) ซึ่งดูเหมือนว่าฉันจะสามารถแสดงผลได้ดีโดยไม่ต้องพังเครื่อง

มีคนอธิบายได้ไหมว่าเพราะอะไร

ฉันตอบคำถามของคุณโดยถามคำถามอื่นกับคุณ:

คุณนับนิ้วของคุณอย่างไรถึง 6

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

คุณถูกต้องว่าจำนวนเต็ม 32 บิตไม่สามารถเก็บค่าที่มากกว่า 2 ^ 32-1 อย่างไรก็ตามค่าของจำนวนเต็ม 32 บิตนี้และลักษณะที่ปรากฏบนหน้าจอของคุณเป็นสองสิ่งที่แตกต่างอย่างสิ้นเชิง สตริงที่พิมพ์ "1000000000000" ไม่ได้ถูกแทนด้วยจำนวนเต็ม 32 บิตในหน่วยความจำ

ในการแสดงตัวเลข "1000000000000" อย่างแท้จริงต้องใช้หน่วยความจำ 13 ไบต์ แต่ละไบต์สามารถมีค่าได้ถึง 255 คนไม่มีใครสามารถถือได้ทั้งค่าตัวเลข แต่ตีความทีละตัวอักษรเป็นอักขระ ASCII (ตัวอย่างเช่นตัวอักษร ' 0' จะถูกแทนด้วยค่าทศนิยม 48, ค่าไบนารี00110000) พวกเขาสามารถ ต้องเครียดกันในรูปแบบที่เหมาะสมสำหรับคุณมนุษย์

แนวคิดที่เกี่ยวข้องในการเขียนโปรแกรมคือtypecastingซึ่งเป็นวิธีที่คอมพิวเตอร์จะตีความกระแสของ0s และ1s ดังในตัวอย่างข้างต้นสามารถตีความได้ว่าเป็นค่าตัวเลขอักขระหรือแม้แต่อย่างอื่น ในขณะที่จำนวนเต็มแบบ 32 บิตอาจไม่สามารถเก็บค่าได้ 1000000000000 แต่ตัวเลขจุดลอยตัวแบบ 32 บิตจะสามารถทำได้โดยใช้การตีความที่แตกต่างอย่างสิ้นเชิง

สำหรับวิธีที่คอมพิวเตอร์สามารถทำงานกับและประมวลผลจำนวนมากภายในนั้นมีจำนวนเต็ม 64- บิต (ซึ่งสามารถรองรับค่ามากถึง 16- หมื่นล้านล้านบาท), ค่าทศนิยม, เช่นเดียวกับไลบรารีพิเศษที่สามารถทำงานกับขนาดใหญ่โดยพลการ หมายเลข

แรกและสำคัญที่สุดคอมพิวเตอร์แบบ 32 บิตสามารถเก็บหมายเลขถึง2³²-1 ในคำที่เครื่องเดียว Machine wordคือปริมาณของข้อมูลที่ CPU สามารถประมวลผลได้อย่างเป็นธรรมชาติ (เช่นการทำงานกับข้อมูลขนาดนั้นจะถูกนำไปใช้ในฮาร์ดแวร์และโดยทั่วไปแล้วจะทำงานได้เร็วที่สุด) 32 บิตซีพียูใช้คำที่ประกอบด้วย 32 บิตทำให้พวกเขาสามารถเก็บตัวเลขจาก 0 ถึง2³²-1 ในหนึ่งคำ

ประการที่สอง1 ล้านล้านและ1000000000000เป็นสองสิ่งที่แตกต่างกัน

• 1 ล้านล้านเป็นแนวคิดที่เป็นนามธรรมของจำนวน
• 1000000000000 เป็นข้อความ

โดยการกด1หนึ่งครั้งจากนั้น012 ครั้งคุณจะพิมพ์ข้อความ 1ปัจจัยการผลิต1, ปัจจัยการผลิต0 0ดู? คุณกำลังพิมพ์อักขระ อักขระไม่ใช่ตัวเลข เครื่องพิมพ์ดีดไม่มีซีพียูหรือหน่วยความจำเลยและพวกมันก็จัดการ "ตัวเลข" ได้ค่อนข้างดีเพราะมันเป็นแค่ข้อความ

พิสูจน์ว่า1000000000000ไม่ใช่ตัวเลข แต่เป็นข้อความ:มันอาจหมายถึง 1 ล้านล้าน (เป็นทศนิยม), 4096 (เป็นเลขฐานสอง) หรือ 281474976710656 (เป็นเลขฐานสิบหก) มันมีความหมายมากขึ้นในระบบที่แตกต่างกัน ความหมายของ1000000000000เป็นตัวเลขและจัดเก็บเป็นเรื่องราวที่แตกต่างกัน (เราจะกลับไปที่อีกสักครู่)

ในการจัดเก็บข้อความ (ในการเขียนโปรแกรมเรียกว่าสตริง ) 1000000000000คุณต้องมี 14 ไบต์ (หนึ่งตัวสำหรับอักขระแต่ละตัวบวกกับ NULL ไบต์ที่สิ้นสุดซึ่งหมายถึง "สตริงสิ้นสุดที่นี่") นั่นคือคำศัพท์ 4 คำ 3 และครึ่งหนึ่งก็เพียงพอแล้ว แต่อย่างที่ฉันพูดการทำงานของคำเครื่องนั้นเร็วที่สุด สมมติว่าASCIIใช้สำหรับการจัดเก็บข้อความดังนั้นในหน่วยความจำจะมีลักษณะดังนี้: (การแปลงรหัส ASCII ที่สอดคล้องกับ0และ1เป็นเลขฐานสองแต่ละคำในบรรทัดแยกต่างหาก)

00110001 00110000 00110000 00110000
00110000 00110000 00110000 00110000
00110000 00110000 00110000 00110000
00110000 00000000 00000000 00000000

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

ตอนนี้กลับไปที่การจัดเก็บตัวเลข มันทำงานเหมือนกับข้อความที่มีการล้น แต่ก็มีการติดตั้งจากขวาไปซ้าย มันอาจฟังดูซับซ้อนดังนั้นนี่เป็นตัวอย่าง เพื่อความเรียบง่ายสมมติว่า:

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

นี่คือหน่วยความจำ 2 คำที่ว่างเปล่า:

0 0
0 0

ลองเก็บหมายเลข 4:

0 4
0 0

ตอนนี้ขอเพิ่ม 9:

1 3
0 0

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

9 9
0 0

อีกครั้งเราใช้ไบต์ที่สองเพื่อเก็บหมายเลข ลองเพิ่ม 1:

0 0
0 0

อ๊ะ ... ที่เรียกว่าจำนวนเต็มล้นและเป็นสาเหตุของการเกิดปัญหาร้ายแรงจำนวนมากบางครั้งก็เป็นคนที่มีราคาแพงมาก

แต่ถ้าเราคาดหวังว่าจะเกิดเหตุการณ์น้ำล้นเราสามารถทำสิ่งนี้ได้:

0 0
9 9

และตอนนี้เพิ่ม 1:

0 1
0 0

มันจะชัดเจนขึ้นถ้าคุณลบช่องว่างและการขึ้นบรรทัดใหม่แบบไบต์:

0099    | +1
0100

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

ทุกสิ่งที่ฉันได้อธิบายไว้ข้างต้นใช้กับหน่วยความจำไบนารีที่มี 8- บิตไบต์และคำ 4 ไบต์เช่นกันมันใช้งานได้ในลักษณะเดียวกัน:

00000000 00000000 00000000 00000000 11111111 11111111 11111111 11111111    | +1
00000000 00000000 00000000 00000001 00000000 00000000 00000000 00000000

แม้ว่าการแปลงตัวเลขดังกล่าวเป็นระบบทศนิยมนั้นค่อนข้างยุ่งยาก (แต่มันทำงานได้ดีกับเลขฐานสิบหก )

นอกจากนี้คุณยังสามารถเขียน"คำชี้แจงนี้เป็นเท็จ"โดยไม่ต้องใช้คอมพิวเตอร์ของคุณหยุดทำงาน :) @ คำตอบของสกอตต์เป็นจุดสำหรับกรอบการคำนวณบางอย่าง แต่คำถามของคุณที่ "เขียน" เป็นจำนวนมากแสดงว่ามันเป็นเพียงข้อความธรรมดาอย่างน้อย มันตีความ

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

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

ขอเริ่มต้นด้วยจำนวนเต็มไม่ได้ลงนาม ในประเภทค่าเหล่านี้บิตทั้งหมดจะถูกใช้เพื่อเก็บข้อมูลเกี่ยวกับตัวเลข ของคุณเป็นตัวอย่างของจำนวนเต็มแบบไม่ได้ลงนามแบบ 32 บิตที่ค่าใด ๆ จาก0ถึง2^32-1สามารถจัดเก็บได้ และใช่ขึ้นอยู่กับภาษาหรือสถาปัตยกรรมของแพลตฟอร์มที่ใช้คุณอาจมีจำนวนเต็ม 16 บิตหรือจำนวนเต็ม 256 บิต

ถ้าคุณต้องการลบ จำนวนเต็มที่ลงนามโดยสังหรณ์ใจคือชื่อของเกม การประชุมคือการจัดสรรค่าทั้งหมดจาก-2^(n-1)ไป2^(n-1)-1- วิธีนี้เราหลีกเลี่ยงความสับสนของการมีการจัดการกับสองวิธีในการเขียนและ+0 -0ดังนั้น 32 บิตลงนามจำนวนเต็มจะถือค่าจากไป-2147483648 2147483647เรียบร้อยใช่ไหม

ตกลงเราได้ครอบคลุมจำนวนเต็มซึ่งเป็นตัวเลขที่ไม่มีส่วนประกอบทศนิยม การแสดงสิ่งเหล่านี้เป็นเรื่องที่ยากขึ้น: ส่วนที่ไม่ใช่จำนวนเต็มสามารถเป็นเพียงส่วนหนึ่งระหว่าง0และ1ดังนั้นทุกบิตพิเศษที่ใช้เพื่ออธิบายมันจะเพิ่มความแม่นยำของมัน: 1/2, 1/4, 1/8 ... ปัญหาคือคุณ ไม่สามารถแสดงทศนิยมอย่างง่ายได้อย่างแม่นยำ0.1เป็นผลรวมของเศษส่วนที่สามารถมีอำนาจสองเท่าในส่วนของพวกเขา! การเก็บตัวเลขเป็นจำนวนเต็มนั้นง่ายกว่านี้หรือไม่ แต่ตกลงที่จะใส่จุดฐาน (ฐานสิบ) แทน? สิ่งนี้เรียกว่าหมายเลขจุดคงที่ซึ่งเราจัดเก็บ1234100แต่เห็นด้วยกับการประชุมเพื่ออ่าน1234.100แทน

floating pointชนิดที่ค่อนข้างทั่วไปที่ใช้สำหรับการคำนวณคือ วิธีการทำงานเป็นระเบียบเรียบร้อยจริง ๆ ใช้บิตหนึ่งเพื่อเก็บค่าเครื่องหมาย มีมาตรฐานที่กำหนดการจัดสรรดังกล่าว แต่สำหรับ32- บิตลอยจำนวนสูงสุดที่คุณจะสามารถเก็บเป็นที่ครอบงำ

(2 - 2^-23) * 2^(2^7 - 1) ≈ 3.4 * 10^38

อย่างไรก็ตามสิ่งนี้มีค่าความแม่นยำสูง JavaScript ที่มีอยู่ในเบราว์เซอร์นั้นใช้ 64- บิตลอยตัว แต่ก็ไม่สามารถทำให้ถูกต้องได้ เพียงคัดลอกสิ่งนี้ลงในแถบที่อยู่แล้วกด Enter การแจ้งเตือนสปอยเลอร์: ผลลัพธ์จะไม่เป็น0.3เช่นนั้น

javascript:alert(0.1+0.2);

มีทางเลือกมากขึ้นเช่น Microsoft .NET 4.5's BigIntegerซึ่งในทางทฤษฎีไม่มีขอบเขตบนหรือล่างและจะต้องมีการคำนวณใน "batches"; แต่บางทีเทคโนโลยีที่น่าสนใจมากขึ้นเป็นคนที่เข้าใจคณิตศาสตร์เช่นเครื่องยนต์ Wolfram Mathematica ซึ่งแม่นยำสามารถทำงานร่วมกับค่านามธรรมเช่นอินฟินิตี้

กุญแจสำคัญคือการทำความเข้าใจวิธีที่คอมพิวเตอร์เข้ารหัสหมายเลข

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

ตัวอย่างหนึ่งคือวิธีที่คอมพิวเตอร์เก็บหมายเลขทศนิยม คอมพิวเตอร์สามารถใช้วิธีต่าง ๆ ในการเข้ารหัส มาตรฐานIEEE 754กำหนดกฎสำหรับการเข้ารหัสตัวเลขที่มีขนาดใหญ่กว่า 2 ^ 32 Crudely คอมพิวเตอร์สามารถใช้สิ่งนี้ได้โดยแบ่ง 32 บิตออกเป็นส่วนต่าง ๆ ซึ่งเป็นตัวเลขหลักของตัวเลขและบิตอื่น ๆ ที่แสดงขนาดของตัวเลข (เช่นเลขชี้กำลัง 10 ^ x) นี้จะช่วยให้มีขนาดใหญ่มากช่วงของตัวเลขในแง่ขนาด แต่ลดความแม่นยำ (ซึ่งก็โอเคสำหรับวัตถุประสงค์มากมาย) แน่นอนว่าคอมพิวเตอร์สามารถใช้มากกว่าหนึ่งคำสำหรับการเข้ารหัสนี้เพิ่มความแม่นยำของขนาดของตัวเลขที่มีการเข้ารหัส เวอร์ชันมาตรฐานทศนิยม 32 อย่างง่ายของ IEEE ช่วยให้ตัวเลขมีความแม่นยำ 7 หลักทศนิยมและตัวเลขสูงถึงประมาณ 10 ^ 96

แต่มีตัวเลือกอื่น ๆ อีกมากมายหากคุณต้องการความแม่นยำเป็นพิเศษ เห็นได้ชัดว่าคุณสามารถใช้คำมากขึ้นในการเข้ารหัสของคุณโดยไม่ จำกัด (แม้ว่าจะมีการลงโทษประสิทธิภาพในการแปลงเป็นและออกจากรูปแบบการเข้ารหัส) หากคุณต้องการสำรวจวิธีหนึ่งสามารถทำได้มี Add-in โอเพนซอร์สที่ยอดเยี่ยมสำหรับ Excel ที่ใช้รูปแบบการเข้ารหัสที่ช่วยให้การคำนวณมีความแม่นยำหลายร้อยหลัก add-in ที่เรียกว่า Xnumbers และสามารถใช้ได้ที่นี่ รหัสอยู่ใน Visual Basic ซึ่งไม่ใช่วิธีที่เร็วที่สุด แต่มีข้อได้เปรียบที่เข้าใจและแก้ไขได้ง่าย มันเป็นวิธีที่ยอดเยี่ยมในการเรียนรู้ว่าคอมพิวเตอร์สามารถเข้ารหัสตัวเลขที่ยาวขึ้นได้อย่างไร และคุณสามารถเล่นกับผลลัพธ์ภายใน Excel ได้โดยไม่ต้องติดตั้งเครื่องมือการเขียนโปรแกรมใด ๆ

ทุกอย่างอยู่ในคำถามของคุณ

คุณสามารถเขียนหมายเลขใด ๆ ที่คุณชอบบนกระดาษ ลองเขียนจุดล้านล้านจุดบนกระดาษขาว มันช้าและไม่มีประสิทธิภาพ นั่นเป็นเหตุผลที่เรามีระบบ 10 หลักเพื่อเป็นตัวแทนจำนวนมากเหล่านั้น เรายังมีชื่อสำหรับคนจำนวนมากเช่น "ล้าน", "ล้านล้าน" และอื่น ๆ ดังนั้นคุณจึงไม่พูดone one one one one one one one one one one...เสียงดัง

โปรเซสเซอร์ 32 บิตได้รับการออกแบบให้ทำงานได้อย่างรวดเร็วและมีประสิทธิภาพมากที่สุดด้วยหน่วยความจำที่มีความยาว 32 หลัก แต่เราคนทั่วไปใช้ระบบตัวเลข 10 หลักและคอมพิวเตอร์เป็นอิเล็กทรอนิกส์ใช้ระบบ 2 หลัก ( ไบนารี ) ตัวเลข 32 และ 64 เกิดขึ้นเป็นพลังของ 2 ดังนั้นหนึ่งล้านและหนึ่งล้านล้านเป็นพลังของ 10 มันง่ายสำหรับเราที่จะทำงานกับตัวเลขเหล่านี้มากกว่า 65536 ตัวอย่างเช่น

เราแบ่งตัวเลขขนาดใหญ่เป็นตัวเลขเมื่อเราเขียนลงบนกระดาษ คอมพิวเตอร์แบ่งตัวเลขออกเป็นตัวเลขที่มากกว่า เราสามารถเขียนหมายเลขที่เราชอบและคอมพิวเตอร์อาจจะถ้าเราออกแบบพวก

32 บิตและ 64 บิตอ้างถึงที่อยู่หน่วยความจำ หน่วยความจำคอมพิวเตอร์ของคุณเป็นเหมือนตู้ไปรษณีย์แต่ละแห่งมีที่อยู่แตกต่างกัน CPU (หน่วยประมวลผลกลาง) ใช้ที่อยู่เหล่านั้นเพื่อระบุตำแหน่งหน่วยความจำบน RAM ของคุณ (หน่วยความจำเข้าถึงโดยสุ่ม) เมื่อ CPU สามารถจัดการกับที่อยู่ 16 บิตเท่านั้นคุณสามารถใช้ RAM ขนาด 32mb เท่านั้น (ซึ่งดูใหญ่ในเวลานั้น) ด้วย 32 บิตมันไปที่ 4 + gb (ซึ่งดูใหญ่ในเวลานั้น) ตอนนี้เรามีที่อยู่ 64 บิตแล้ว RAM จะเปลี่ยนเป็นเทราไบต์
อย่างไรก็ตามโปรแกรมสามารถจัดสรรหน่วยความจำหลายบล็อกสำหรับสิ่งต่าง ๆ เช่นการเก็บหมายเลขและข้อความซึ่งขึ้นอยู่กับโปรแกรมและไม่เกี่ยวข้องกับขนาดของแต่ละที่อยู่ ดังนั้นโปรแกรมสามารถบอกซีพียูได้ฉันจะใช้ที่อยู่ 10 บล็อกของที่เก็บข้อมูลแล้วเก็บจำนวนมากหรือสตริงตัวอักษร 10 ตัวหรืออะไรก็ตาม
หมายเหตุด้านข้าง: ที่อยู่หน่วยความจำถูกชี้ไปที่ "พอยน์เตอร์" ดังนั้นค่า 32- และ 64- บิตหมายถึงขนาดของตัวชี้ที่ใช้ในการเข้าถึงหน่วยความจำ

เนื่องจากการแสดงตัวเลขทำได้โดยใช้อักขระแต่ละตัวไม่ใช่จำนวนเต็ม หลักในจำนวนแต่ละครั้งจะถูกแทนด้วยตัวอักษรที่แยกต่างหากที่แท้จริงที่มีจำนวนเต็มค่าจะถูกกำหนดโดยการเข้ารหัสที่ถูกนำมาใช้เช่น'a'เป็นตัวแทนกับค่า ASCII 97ในขณะที่มีการแสดงด้วย'1' 49ตรวจสอบตาราง ASCII ที่นี่
สำหรับการแสดงทั้ง 'a' และ '1' เหมือนกัน เป็นอักขระตัวอักษรไม่ใช่จำนวนเต็ม ตัวอักษรแต่ละตัวได้รับอนุญาตให้มีค่าสูงสุด 255 ในแพลตฟอร์ม 32- บิตที่เก็บค่าในขนาด 8 บิตหรือ 1 ไบต์ (ขึ้นอยู่กับแพลตฟอร์ม แต่ 8 บิตเป็นขนาดตัวอักษรที่พบบ่อยที่สุด) ดังนั้นพวกเขาสามารถจัดกลุ่มเข้าด้วยกันและสามารถ แสดง จำนวนตัวอักษรที่สามารถแสดงได้นั้นขึ้นอยู่กับ RAM ที่คุณมี หากคุณมี RAM เพียง 1 ไบต์คุณสามารถแสดงอักขระได้เพียงตัวเดียวหากคุณมี RAM 1GB คุณสามารถแสดงอักขระได้ดี 1024 * 1024 * 1024 ตัวอักษร (ขี้เกียจเกินกว่าที่จะทำคณิตศาสตร์)

อย่างไรก็ตามข้อ จำกัด นี้ใช้กับการคำนวณอย่างไรก็ตามฉันคิดว่าคุณสนใจมาตรฐาน IPV4 แม้ว่ามันจะไม่เกี่ยวข้องกับคอมพิวเตอร์ทั้งหมดbit-sizeมันส่งผลกระทบต่อมาตรฐาน เมื่อสร้างมาตรฐาน IPV4 พวกเขาจะเก็บค่า ip เป็นจำนวนเต็ม 32 บิต ตอนนี้เมื่อคุณให้ขนาดและมันกลายเป็นมาตรฐาน ทุกสิ่งที่เรารู้เกี่ยวกับอินเทอร์เน็ตนั้นขึ้นอยู่กับสิ่งนั้นและจากนั้นเราก็หมดที่อยู่ IP เพื่อกำหนด ดังนั้นหากมาตรฐาน IP ได้รับการปรับปรุงให้มี 64 บิตทุกอย่างจะหยุดทำงานรวมถึงเราเตอร์ของคุณ (ฉันถือว่านี่ถูกต้อง) และอุปกรณ์เครือข่ายอื่น ๆ ดังนั้นต้องสร้างมาตรฐานใหม่ซึ่งเพิ่งเปลี่ยนจำนวนเต็ม 32 บิตเป็น 128 บิต และปรับตามมาตรฐานที่เหลือ ผู้ผลิตฮาร์ดแวร์เพียงแค่ต้องประกาศว่าพวกเขาสนับสนุนมาตรฐานใหม่นี้และมันจะได้รับไวรัส แม้ว่ามันจะไม่ง่าย แต่ฉันคิดว่าคุณมาถึงจุดนี้

ข้อสงวนสิทธิ์:คะแนนส่วนใหญ่ที่กล่าวถึงในที่นี้เป็นจริงตามที่ฉันสันนิษฐาน ฉันอาจพลาดจุดสำคัญที่นี่เพื่อทำให้ง่ายขึ้น ฉันไม่ดีกับตัวเลขดังนั้นต้องพลาดตัวเลขบางส่วน แต่จุดของฉันที่นี่คือการตอบคำตอบของ OP เกี่ยวกับสาเหตุที่พีซีไม่ทำงานผิดพลาด

ในโปรเซสเซอร์มี "คำ" มีคำที่แตกต่างกัน เมื่อมีคนพูดว่า "โปรเซสเซอร์ 32 บิต" พวกเขาส่วนใหญ่หมายถึง "ความกว้างบัสหน่วยความจำ" คำนี้ประกอบด้วย "ฟิลด์" ที่แตกต่างกันซึ่งอ้างถึงระบบย่อยของคอมพิวเตอร์ที่สอดคล้องกับการส่งสัญญาณ (24 บิต) และการควบคุม (บิตอื่น ๆ ) ฉันอาจผิดเกี่ยวกับตัวเลขที่แน่นอนทำให้ตัวเองมั่นใจในคู่มือ

ด้านที่แตกต่างอย่างสิ้นเชิงคือการคำนวณ ชุดคำสั่ง SSE และ MMX สามารถเก็บจำนวนเต็มแบบยาวได้ ความยาวสูงสุดโดยไม่สูญเสียความสามารถในการผลิตขึ้นอยู่กับรุ่น SSE ปัจจุบัน แต่ความยาวสูงสุดอยู่ที่ 64 บิต

ตัวประมวลผล Opteron ปัจจุบันสามารถจัดการกับตัวเลขที่มีความกว้าง 256 บิต (ฉันไม่แน่ใจเกี่ยวกับจำนวนเต็ม แต่การลอยนั้นแน่นอน)

สรุป : (1) ความกว้างของบัสไม่ได้เชื่อมต่อกับความกว้างในการคำนวณโดยตรง (2) คำที่ต่างกัน (หน่วยความจำคำลงทะเบียนคำบัส ฯลฯ ) ไม่ได้เชื่อมต่อกัน 24. ตัวประมวลผลจำนวนมากใช้คำ 6 บิต (แต่เป็นประวัติของมัน)

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

ซอฟต์แวร์คือรหัสที่บอกเครื่องถึงวิธีการรับข้อมูลวิธีการประมวลผลวิธีจัดเก็บและวิธีการให้เครื่องแก่ผู้อื่น

ฮาร์ดแวร์พื้นฐานจะมีข้อ จำกัด อยู่เสมอ ในกรณีของเครื่อง 32 บิตเรจิสเตอร์ส่วนใหญ่ที่ประมวลผลข้อมูลมีความกว้างเพียง 32 บิต นี่ไม่ได้หมายความว่าเครื่องไม่สามารถจัดการกับตัวเลขที่เกินกว่า 2 ^ 32 ได้นั่นหมายความว่าหากคุณต้องการจัดการกับตัวเลขที่มีขนาดใหญ่กว่าอาจใช้เครื่องจักรมากกว่าหนึ่งรอบเพื่อยอมรับประมวลผลจัดเก็บ มันหรือปล่อยมัน

ซอฟต์แวร์จะบอกเครื่องถึงวิธีจัดการกับหมายเลข หากซอฟต์แวร์ได้รับการออกแบบให้รองรับจำนวนมากซอฟต์แวร์จะส่งชุดคำสั่งไปยัง CPU เพื่อบอกวิธีจัดการหมายเลขที่มีขนาดใหญ่กว่า ตัวอย่างเช่นหมายเลขของคุณสามารถแสดงโดยการลงทะเบียน 32 บิตสองรายการ หากคุณต้องการเพิ่ม 1,234 ไปยังหมายเลขของคุณซอฟต์แวร์จะบอก CPU ให้เพิ่ม 1,234 ลงในฐานข้อมูลด้านล่างก่อนจากนั้นตรวจสอบบิตล้นเพื่อดูว่าการเพิ่มนั้นส่งผลให้ตัวเลขใหญ่เกินไปสำหรับการลงทะเบียนต่ำกว่าหรือไม่ ถ้าเป็นเช่นนั้นจะเพิ่ม 1 ลงในการลงทะเบียนด้านบน

ในทำนองเดียวกันเด็กนักเรียนชั้นประถมจะได้รับการสอนให้เพิ่มด้วยการพกพา CPU สามารถบอกให้จัดการกับตัวเลขที่ใหญ่กว่าที่จะเก็บไว้ในการลงทะเบียนครั้งเดียว สิ่งนี้เป็นจริงสำหรับการดำเนินการทางคณิตศาสตร์ทั่วไปส่วนใหญ่สำหรับจำนวนของขนาดที่ใช้ได้จริง

ความแตกต่างอยู่ที่วิธีการที่เราเก็บข้อมูลในคอมพิวเตอร์

คุณถูกต้องว่าสำหรับเครื่อง 8 บิตตามหลักทฤษฎีเราสามารถเก็บค่า 2 ^ 8 ไว้ในหน่วยประมวลผลเดี่ยวหรือที่อยู่หน่วยความจำเท่านั้น (โปรดจำไว้ว่าสิ่งนี้จะแตกต่างกันไปจาก "เครื่องจักร" ถึง "เครื่อง" ซึ่งขึ้นอยู่กับหน่วยประมวลผลที่ใช้สถาปัตยกรรมหน่วยความจำ ฯลฯ แต่สำหรับตอนนี้ขอติดอยู่กับเครื่อง 'ตายตัว' สมมุติฐาน)

สำหรับเครื่อง 16- บิตตามทฤษฎีค่าสูงสุดในตำแหน่งรีจิสเตอร์ / หน่วยความจำจะเป็น 2 ^ 16 สำหรับเครื่อง 32- บิต 2 ^ 32 เป็นต้น

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

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

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

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

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

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

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

ตัวประมวลผล Intel 32 บิตปกติสามารถจัดการหมายเลข 128 บิตภายในซึ่งจะช่วยให้คุณสามารถจัดการกับตัวเลขเช่น 1000000000000000000000000000000000000000000 โดยไม่มีปัญหาใด ๆ

คุณสามารถจัดการกับตัวเลขที่ใหญ่กว่าในคอมพิวเตอร์ได้ แต่จากนั้นต้องคำนวณโดยซอฟต์แวร์ CPU ไม่มีคำแนะนำในการจัดการตัวเลขที่มีขนาดใหญ่กว่า 128 บิต (สามารถจัดการกับตัวเลขที่มีขนาดใหญ่กว่าในรูปของตัวเลขทศนิยมได้ แต่คุณมีความแม่นยำเพียง 15 หลัก)

เพียงเพิ่มบันทึกย่อไปยังคำตอบอื่น ๆ อีกมากมายเพราะนี่เป็นข้อเท็จจริงที่สำคัญมากสำหรับคำถามนี้ที่ไม่ได้รับ

"32 บิต" หมายถึงความกว้างของที่อยู่หน่วยความจำ มันไม่มีอะไรเกี่ยวข้องกับขนาดการลงทะเบียน ซีพียู 32 บิตจำนวนมากมีแนวโน้มที่จะลงทะเบียน 64 หรือ 128 บิต โดยเฉพาะอย่างยิ่งการอ้างถึงสายผลิตภัณฑ์ x86 ซีพียูผู้บริโภคล่าสุดซึ่งเป็น 64 บิตทั้งหมดมีการลงทะเบียนมากถึง 256 บิตสำหรับวัตถุประสงค์พิเศษ

ความแตกต่างระหว่างความกว้างของรีจิสเตอร์กับความกว้างของที่อยู่นี้มีมาตั้งแต่สมัยโบราณเมื่อเรามีรีจิสเตอร์ 4 บิตและที่อยู่ 8 บิตหรือในทางกลับกัน

มันง่ายที่จะเห็นว่าการจัดเก็บจำนวนมากนั้นไม่มีปัญหาไม่ว่าขนาดการลงทะเบียนจะเป็นอย่างไรดังอธิบายในคำตอบอื่น ๆ

เหตุผลที่ทำไมขนาดของสิ่งที่พวกเขาอาจจะเกิดขึ้นนอกจากนี้ยังสามารถคำนวณด้วยจำนวนที่มากขึ้นคือการคำนวณที่มีขนาดใหญ่เกินไปสามารถแบ่งออกเป็นขนาดเล็ก ๆ หลายขนาดที่พอดีกับรีจิสเตอร์ (มันซับซ้อนขึ้นเล็กน้อย ในความเป็นจริง).

คำตอบที่ได้รับนั้นค่อนข้างดี แต่พวกเขามักจะแก้ไขปัญหาจากด้านต่าง ๆ และนำเสนอภาพที่ไม่สมบูรณ์ พวกเขามีความรู้ด้านเทคนิคมากไปหน่อย

ดังนั้นเพื่ออธิบายสิ่งที่ถูกบอกกล่าว แต่ไม่ได้แสดงออกอย่างชัดเจนในคำตอบอื่นใดและฉันคิดว่าเป็นประเด็นสำคัญของเรื่อง:

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

อย่างชัดเจน:

• "IPv4 / 6" หมายถึงโปรโตคอลอินเทอร์เน็ตชุดของกฎที่กำหนดว่าจะบรรจุและตีความข้อมูลบนอินเทอร์เน็ตอย่างไร ความแตกต่างหลัก (หรืออย่างน้อยที่สุดที่รู้จักกันดีที่สุด) ความแตกต่างระหว่าง IPv4 และ IPv6 คือพื้นที่ที่อยู่ (เช่นชุดของที่อยู่ที่สามารถใช้ในการแยกแยะความแตกต่างระหว่างสถานที่ต่าง ๆ บนเครือข่าย) มีขนาดใหญ่กว่าใน IPv6 สิ่งนี้เกี่ยวข้องกับจำนวนบิตในแต่ละแพ็คเก็ตของข้อมูลที่ส่งผ่านเครือข่ายที่ถูกจัดสรรสำหรับ (เช่นตั้งไว้เพื่อวัตถุประสงค์) ระบุผู้ส่งของแพ็กเก็ตและผู้รับที่ต้องการ
  • การเปรียบเทียบที่ไม่ใช้คอมพิวเตอร์: แต่ละแพ็คเก็ตเป็นเหมือนจดหมายที่ส่งผ่านทางหอยทากและพื้นที่ที่อยู่นั้นก็เหมือนกับจำนวนตัวอักษรที่คุณ "อนุญาต" ให้ใช้เมื่อเขียนที่อยู่และที่อยู่ผู้ส่งคืนบนซองจดหมาย
  • ฉันไม่เห็นสิ่งนี้พูดถึงในคำตอบอื่น ๆ
• คอมพิวเตอร์ - หน่วยความจำ "คำ" (32- บิตและ 64- บิต) โดยทั่วไปจะคิดว่าเป็นชิ้นส่วนเล็ก ๆ ของข้อมูลที่คอมพิวเตอร์ใช้หรือ "คิด" นิ้วข้อมูลเหล่านี้มารวมกันเป็นเศษเล็กเศษน้อยของข้อมูลอื่น ๆ เช่นจำนวนข้อความหรือจำนวนเต็มที่มากกว่า
  • การเปรียบเทียบที่ไม่ได้ใช้คอมพิวเตอร์: คำต่าง ๆ สามารถคิดได้เช่นตัวอักษรที่เขียนขึ้นบนกระดาษหรือแม้แต่คำเดียวในรถไฟแห่งความคิด
  • ดูคำตอบของ Guffa , คำตอบ sanaris ของและวรรคแรกของคำตอบของ gronostaj
• ตัวชี้แบบ 32 บิตอาจหรือไม่อาจเป็นคำ แต่ก็ยังคงได้รับการปฏิบัติตามอะตอม พอยน์เตอร์เป็นวิธีที่มีระดับต่ำสุดที่คอมพิวเตอร์สามารถบันทึกตำแหน่งในหน่วยความจำของกลุ่มข้อมูลได้โดยพลการ โปรดทราบว่าขนาดตัวชี้ที่ใช้โดยคอมพิวเตอร์ (หรือจริงๆแล้วโดยระบบปฏิบัติการ) จะ จำกัด ช่วงของหน่วยความจำที่สามารถเข้าถึงได้โดยตัวชี้เดียวเนื่องจากมีตำแหน่งหน่วยความจำที่เป็นไปได้จำนวนมากที่ตัวชี้สามารถ "ชี้" ถึง เนื่องจากมีค่าที่เป็นไปได้สำหรับตัวชี้ นี่คล้ายกับวิธีที่ IPv4 จำกัด ช่วงของที่อยู่อินเทอร์เน็ตที่เป็นไปได้ แต่ไม่ได้จำกัด จำนวนข้อมูลที่สามารถมีอยู่ในเว็บเพจตัวอย่างเช่น อย่างไรก็ตามขนาดตัวชี้ไม่ได้จำกัด ขนาดของข้อมูลที่ตัวชี้สามารถชี้ได้ (สำหรับตัวอย่างของแบบแผนสำหรับการอนุญาตให้ขนาดข้อมูลเกินช่วงตัวชี้ตรวจสอบโครงสร้างตัวชี้ไอโหนดของ Linux โปรดสังเกตว่านี่เป็นการใช้คำว่า "ตัวชี้" ที่แตกต่างกันเล็กน้อยกว่าปกติเนื่องจากตัวชี้มักจะอ้างถึงตัวชี้ไป หน่วยความจำเข้าถึงโดยสุ่มไม่ใช่พื้นที่ฮาร์ดไดรฟ์)
  • การเปรียบเทียบที่ไม่ใช้คอมพิวเตอร์: อืมม .... มันค่อนข้างยุ่งยาก บางทีระบบทศนิยมของดิวอี้สำหรับการทำดัชนีวัสดุในห้องสมุดนั้นค่อนข้างคล้ายคลึงกัน? หรือระบบการจัดทำดัชนีใด ๆ จริงๆ
  • ดูคำตอบของ SiteNook
  • โปรดทราบว่าคำอธิบายของฉันเกี่ยวกับตัวชี้ด้านบนจะอธิบายรายละเอียดที่ละเอียดบางอย่างและไม่ถูกต้องทั้งหมด อย่างไรก็ตามในการเขียนโปรแกรมภาษาที่โปรแกรมเมอร์ทำงานโดยตรงกับพอยน์เตอร์โหมดทางจิตที่ฉันวาดมักจะเพียงพอสำหรับการใช้งานจริง
• ตัวเลขที่คอมพิวเตอร์เป็น "สามารถที่จะแสดง"ไม่ได้ (สำหรับวัตถุประสงค์ในทางปฏิบัติ) จำกัด โดยฮาร์ดแวร์หรือระบบปฏิบัติการของคอมพิวเตอร์; พวกเขาจะได้รับการปฏิบัติเหมือนข้อความอื่น ๆ
  • การเปรียบเทียบแบบไม่คำนวณ: เขียนบนกระดาษ
  • ดูคำตอบของ user1306322และคำตอบของ Bigbio2002

โปรดทราบว่านี่ไม่ได้มีวัตถุประสงค์เพื่อเป็นรายการการตีความที่ครอบคลุมสำหรับวลี "32 บิต"

เครดิตเสริม: จริงๆเห็นกระดูกเปลือยความแตกต่างระหว่างตัวเลขปรัชญาและชิ้นดั้งเดิมของหน่วยความจำคอมพิวเตอร์อ่านเล็กน้อยเกี่ยวกับเครื่องจักรทัวริง

ถ้าคุณเขียน 1000000000000 เช่นในเครื่องคิดเลข, เครื่องคอมพิวเตอร์จะคำนวณเป็นประเภทอสังหาริมทรัพย์จำนวนที่มีจุดทศนิยม จำกัด จำนวน 32 บิตที่คุณกล่าวถึงแตะจำนวนประเภทจำนวนเต็มทั้งหมดโดยไม่มีจุดทศนิยม ชนิดข้อมูลที่แตกต่างกันใช้วิธีการต่าง ๆ ในการรับบิต / ไบต์

หมายเลขประเภทเลขจำนวนเต็ม : ตารางนี้สามารถช่วยให้คุณตรวจจับจุด ( http://msdn.microsoft.com/en-us/library/296az74e.aspx ) สัมผัสนี้ จำกัด สำหรับ C ++ ตัวอย่างเช่นหมายเลขชนิด Int64มีข้อ จำกัด จาก -9223372036854775808 ถึง 9223372036854775807

หมายเลขประเภทจริง : หมายเลขประเภทจริงประกอบด้วยค่าที่มีจำนวนจุดลอยตัวและเลขชี้กำลังและคุณสามารถป้อนตัวเลขที่มากขึ้น แต่มีความแม่นยำ / ความแม่นยำ จำกัด ( http://msdn.microsoft.com/en-us/library/6bs3y5ya.aspx ) ตัวอย่างเช่น LDBL (คู่ใหญ่) ใน C ++ มีเลขชี้กำลังสูงสุด 308 ดังนั้นคุณอาจป้อนหรือมีหมายเลขผลลัพธ์9.999 x 10^308หมายความว่าคุณจะ ในทางทฤษฎีมีจำนวน 308 (+1) หลัก9แต่มีเพียง 15 หลักที่สำคัญที่สุดเท่านั้นที่จะถูกใช้เพื่อเป็นตัวแทนส่วนที่เหลือจะหายไปสาเหตุของความแม่นยำที่ จำกัด

นอกจากนี้ยังมีภาษาการเขียนโปรแกรมที่แตกต่างกันและพวกเขาอาจมีการใช้งานที่แตกต่างกันของการ จำกัด จำนวน ดังนั้นคุณสามารถจินตนาการได้ว่าแอปพลิเคชันพิเศษสามารถจัดการกับจำนวนที่มากขึ้น (และ / หรือแม่นยำ / แม่นยำ) มากกว่า C ++

ในกรณีที่คุณต้องการตัวอย่างที่ใช้งานได้จริงของจำนวนโปรแกรมบนระบบ Linux ทั่วไปที่จัดการกับการประมวลผลจำนวนมากและแสดงผล:

libgmp- GNU Multiple Precision Arithmetic Libraryเป็นห้องสมุดที่ใช้กันอย่างแพร่หลายสำหรับจุดประสงค์นี้ในระบบ Linux ตัวอย่างง่ายๆของการคูณ 2 ^ 80 คูณ 1,000:

#include <gmp.h>

// Each large integer uses the mpz_t type provided by libgmp
mpz_t a_large_number;
mpz_t base;
mpz_t result;

// Initalize each variable
mpz_init(a_large_number);
mpz_init(base);
mpz_init(result);

// Assign the number 2 to the variable |base|
mpz_set_ui(base, 2);

// Raise base^80 (2^80), store the result in |a_large_number|
mpz_pow_ui(a_large_number, base, 80);

// Multiply |a_large_number| by 1000, store the result in |result|
mpz_mul_ui(result, a_large_number, 1000);

// Finally, output the result in decimal and hex notation
gmp_printf("decimal: %Zd, hex: %ZX\n", result, result);

ดังนั้นโดยพื้นฐานแล้วมันก็เหมือนกับการใช้ตัวดำเนินการ + - * / ปกติเพียงแค่มีไลบรารีเพื่อแบ่งตัวเลขและจัดเก็บไว้ภายในเป็นตัวเลขคำที่มีขนาดเครื่อง (เช่น 32 บิต) หลายเครื่อง นอกจากนี้ยังมีฟังก์ชันชนิด scanf () สำหรับการจัดการการแปลงข้อความเป็นชนิดจำนวนเต็ม

โครงสร้างของmpz_tนั้นเหมือนกับตัวอย่างของ Scott Chamberlain ที่นับถึง 6 โดยใช้สองมือ โดยทั่วไปแล้วเป็นประเภทของคำที่มีขนาดเครื่องmp_limb_tและเมื่อตัวเลขมีขนาดใหญ่เกินไปที่จะพอดีกับคำของเครื่อง GMP จะใช้หลายรายการmp_limb_tเพื่อเก็บส่วนสูง / ต่ำของจำนวน

ในใจคุณรู้แค่ 10 หลักเท่านั้น 0 ถึง 9 ภายในสมองของคุณการเข้ารหัสนี้แตกต่างจากในคอมพิวเตอร์อย่างแน่นอน

คอมพิวเตอร์ใช้บิตเพื่อเข้ารหัสตัวเลข แต่ไม่สำคัญ นั่นเป็นเพียงวิธีที่วิศวกรเลือกที่จะเข้ารหัสสิ่งต่างๆ แต่คุณควรเพิกเฉยต่อสิ่งนั้น คุณสามารถคิดได้ว่ามันเป็นคอมพิวเตอร์ 32 บิตมีการแสดงค่าที่แตกต่างกันมากกว่า 4 พันล้านค่าในขณะที่มนุษย์เรามีการแทนค่าที่แตกต่างกันถึง 10 ค่า

เมื่อใดก็ตามที่เราต้องเข้าใจจำนวนที่มากขึ้นเราจะใช้ระบบ จำนวนซ้ายสุดสำคัญที่สุด มีความสำคัญมากกว่าครั้งต่อไปถึง 10 เท่า

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

เมื่อใดก็ตามที่ค่ามากกว่าจำนวนสัญลักษณ์ที่ไม่ซ้ำกัน 9 ในจิตใจมนุษย์คุณเพิ่มหนึ่งไปยังหมายเลขทางด้านซ้าย

3+3=6

ในกรณีนี้จำนวนยังคงพอดีภายใน "ช่อง" เดียว

5+5=10. This situation is called an overflow.

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

987+321 is more difficult.

คุณอาจเรียนรู้วิธีการในโรงเรียน อัลกอริทึม อัลกอริทึมนั้นค่อนข้างง่าย เริ่มต้นด้วยการเพิ่มสัญลักษณ์ทางซ้ายสุดที่สอง

7+1=8, we now have ...8 as the result so far

จากนั้นคุณย้ายไปยังสล็อตถัดไปและดำเนินการเพิ่มเดียวกัน

8+2=10, the overflow flag is raised. We now have ...08, plus overflow.

เนื่องจากเรามีข้อมูลมากเกินไปหมายความว่าเราต้องเพิ่ม 1 ไปยังหมายเลขถัดไป

9+3=12, and then we add one due to overflow. ...308, and we had another overflow.

ไม่มีตัวเลขที่จะเพิ่มอีกดังนั้นเราเพียงสร้างสล็อตและแทรก 1 เนื่องจากการตั้งค่าสถานะโอเวอร์โฟลว์

1308

คอมพิวเตอร์ใช้วิธีเดียวกันทุกประการยกเว้นคอมพิวเตอร์ที่มีสัญลักษณ์ 2 ^ 32 หรือสัญลักษณ์ 2 ^ 64 ที่ดีกว่าแทนที่จะเป็น 10 เหมือนมนุษย์

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

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

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

เนื้อหาส่วนใหญ่ของของคำตอบนี้เดิมมาจากคำตอบนี้ (เขียนก่อนที่คำถามอื่น ๆ ที่ถูกทำเครื่องหมายว่าซ้ำกัน) ดังนั้นฉันจึงหารือเกี่ยวกับการใช้ค่า 8 บิต (แม้ว่าคำถามนี้ถามเกี่ยวกับค่า 32- บิต) แต่ก็ไม่เป็นไรเพราะค่า 8 บิตนั้นง่ายกว่าที่จะเข้าใจแนวคิดและแนวคิดเดียวกันนี้ใช้กับค่าที่ใหญ่กว่าเช่นเลขคณิต 32 บิต

เมื่อคุณเพิ่มตัวเลขสองตัวที่เป็น 8 บิตจำนวนที่มากที่สุดที่คุณจะได้รับคือ (0xFF + 0xFF = 1FE) ในความเป็นจริงถ้าคุณคูณสองตัวเลขที่เป็น 8 บิตตัวเลขที่ใหญ่ที่สุดที่คุณจะได้รับ (0xFF * 0xFF = 0xFE01) ยังคงเป็น 16 บิตสองเท่าของ 8 บิต

ตอนนี้คุณอาจสมมติว่าตัวประมวลผล x-bit สามารถติดตาม x-bits ได้เท่านั้น (ตัวอย่างเช่นโปรเซสเซอร์ 8 บิตสามารถติดตาม 8 บิตเท่านั้น) นั่นไม่ถูกต้อง ตัวประมวลผล 8 บิตรับข้อมูลในกลุ่มแบบ 8 บิต (โดยทั่วไป "chunks" เหล่านี้มีคำที่เป็นทางการ: "word" ในตัวประมวลผล 8 บิตจะใช้คำ 8 บิตบนตัวประมวลผล 64 บิตสามารถใช้คำ 64 บิตได้)

ดังนั้นเมื่อคุณให้คอมพิวเตอร์ 3 ไบต์:
ไบต์ # 1: คำสั่ง MUL
ไบต์ # 2: ไบต์ลำดับสูง (เช่น 0xA5)
ไบต์ # 3: ไบต์ลำดับที่ต่ำกว่า (เช่น 0xCB)
คอมพิวเตอร์สามารถสร้างผลลัพธ์ที่ มากกว่า 8 บิต CPU อาจสร้างผลลัพธ์เช่นนี้:
0100 0000 0100 0010 xxxx xxxx xxxx 1101 0111
aka:
0x4082xxxxD7
ทีนี้ขอผมแปลมันให้คุณ:
0x หมายถึงเลขฐานสิบหกต่อไปนี้
ฉันจะหารือเกี่ยวกับ "40" ในรายละเอียดเพิ่มเติมในไม่ช้า
82 เป็นส่วนหนึ่งของการลงทะเบียน "A" ซึ่งเป็นชุดของ 8 บิต
xx และ xx เป็นส่วนหนึ่งของการลงทะเบียนอีกสองรายการชื่อการลงทะเบียน "B" และการลงทะเบียน "C" เหตุผลที่ฉันไม่ได้เติมบิตเหล่านั้นด้วยค่าศูนย์หรืออันใดอันหนึ่งก็คือคำสั่ง "เพิ่ม" (ส่งไปยัง CPU) อาจส่งผลให้บิตเหล่านั้นไม่เปลี่ยนแปลงตามคำสั่ง (ในขณะที่บิตอื่น ๆ ที่ฉันใช้ในตัวอย่างนี้อาจ รับการแก้ไขยกเว้นบิตแฟล็กบางตัว)
D7 จะพอดีกับบิตเพิ่มเติมเรียกว่า "D" register
การลงทะเบียนเป็นเพียงส่วนหนึ่งของหน่วยความจำ รีจิสเตอร์ถูกสร้างไว้ใน CPU ดังนั้น CPU สามารถเข้าถึงรีจิสเตอร์โดยไม่จำเป็นต้องโต้ตอบกับหน่วยความจำบน RAM stick

ดังนั้นผลลัพธ์ทางคณิตศาสตร์ของ 0xA5 คูณ 0xCB คือ 0x82D7

ทีนี้ทำไมเศษเล็กเศษน้อยถูกแบ่งออกเป็นรีจิสเตอร์ A และ D แทนที่จะรีจิสเตอร์ A และ B หรือรีจิสเตอร์ C และ D? นี่เป็นตัวอย่างสถานการณ์ที่ฉันใช้ซึ่งคล้ายกับแนวคิดในภาษาแอสเซมบลีที่แท้จริง (Intel x86 16 บิตซึ่งใช้โดย Intel 8080 และ 8088 และซีพียูรุ่นใหม่กว่า) อาจมีกฎทั่วไปบางอย่างเช่นการลงทะเบียน "C" โดยทั่วไปจะใช้เป็นดัชนีสำหรับการนับการดำเนินการ (โดยทั่วไปสำหรับลูป) และการลงทะเบียน "B" ที่ใช้ในการติดตามการออฟเซ็ตที่ช่วยระบุตำแหน่งหน่วยความจำ ดังนั้น "A" และ "D" อาจเป็นเรื่องธรรมดาสำหรับฟังก์ชันเลขคณิตทั่วไปบางอย่าง

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

ตอนนี้กลับไปที่ "40" ในตัวอย่างข้างต้นนั่นคือชุดของบิตที่มักจะเรียกว่า "การลงทะเบียนธง" แต่ละบิตในการลงทะเบียนสถานะมีชื่อ ตัวอย่างเช่นมีบิต "โอเวอร์โฟลว์" ที่ CPU อาจตั้งค่าหากผลลัพธ์มีขนาดใหญ่กว่าพื้นที่ที่สามารถเก็บหนึ่งไบต์ของผลลัพธ์ (บิต "ล้น" อาจถูกอ้างถึงโดยชื่อย่อของ "OF" นั่นคือทุน o ไม่ใช่ศูนย์) ซอฟต์แวร์สามารถตรวจสอบค่าของการตั้งค่าสถานะนี้และสังเกตเห็นปัญหา " การทำงานกับบิตนี้มักจะถูกจัดการอย่างล่องหนโดยภาษาระดับสูงกว่าดังนั้นผู้เริ่มต้นโปรแกรมเมอร์มักจะไม่เรียนรู้เกี่ยวกับวิธีการโต้ตอบกับค่าสถานะของ CPU อย่างไรก็ตามโปรแกรมเมอร์แอสเซมบลีอาจเข้าถึงค่าสถานะเหล่านี้บางอย่างในลักษณะคล้ายกับตัวแปรอื่น ๆ

ตัวอย่างเช่นคุณอาจมีคำแนะนำเพิ่มหลายรายการ คำสั่ง ADD หนึ่งคำสั่งอาจเก็บ 16 บิตของผลลัพธ์ใน A register และ D register ในขณะที่คำสั่งอื่นอาจเก็บ 8 low bits ในการลงทะเบียน A ละเว้นการลงทะเบียน D และระบุ overflow bit จากนั้นในภายหลัง (หลังจากเก็บผลลัพธ์ของการลงทะเบียน A ลงใน RAM หลัก) คุณสามารถใช้คำสั่ง ADD อื่นที่เก็บเพียง 8 บิตสูงในการลงทะเบียน (อาจเป็นการลงทะเบียน A) ไม่ว่าคุณจะต้องใช้ธงล้นอาจ ขึ้นอยู่กับคำสั่งการคูณที่คุณใช้

(นอกจากนี้ยังมีธง "underflow" โดยทั่วไปในกรณีที่คุณลบมากเกินไปเพื่อให้พอดีกับผลลัพธ์ที่ต้องการ)

เพื่อแสดงให้คุณเห็นว่าสิ่งต่าง ๆ มีความซับซ้อน:
Intel 4004 เป็นซีพียู 4 บิต
Intel 8008 เป็นซีพียู 8 บิต มีรีจิสเตอร์ 8 บิตชื่อ A, B, C และ D
Intel 8086 เป็นซีพียู 16 บิต มีรีจิสเตอร์ 16 บิตชื่อ AX, BX, CX และ DX
Intel 80386 เป็น CPU แบบ 32 บิต มีรีจิสเตอร์ 32 บิตชื่อ EAX, EBX, ECX และ EDX
Intel x64 CPUs มีการลงทะเบียน 64 บิตชื่อ RAX, RBX, RCX และ RDX ชิป x64 สามารถเรียกใช้รหัส 16 บิต (ในบางโหมดปฏิบัติการ) และสามารถตีความคำสั่ง 16 บิตได้ เมื่อทำเช่นนั้นบิตที่ประกอบขึ้นทะเบียน AX คือครึ่งหนึ่งของบิตที่ทำขึ้นทะเบียน EAX ซึ่งเป็นครึ่งหนึ่งของบิตที่ทำขึ้นทะเบียน RAX ดังนั้นเมื่อใดก็ตามที่คุณเปลี่ยนค่าของ AX คุณจะเปลี่ยน EAX และ RAX ด้วยเพราะบิตเหล่านั้นที่ใช้โดย AX นั้นเป็นส่วนหนึ่งของบิตที่ RAX ใช้ (ถ้าคุณเปลี่ยน EAX ด้วยค่าที่เป็นทวีคูณของ 65,536 ดังนั้น 16 บิตต่ำจะไม่เปลี่ยนแปลงดังนั้น AX จะไม่เปลี่ยนแปลงหากคุณเปลี่ยน EAX ด้วยค่าที่ไม่ใช่หลาย 65,536 นั่นก็จะส่งผลต่อ AX เช่นกัน .)

มีการตั้งค่าสถานะและการลงทะเบียนมากกว่าสิ่งที่ฉันได้กล่าวถึง ฉันเพียงแค่เลือกสิ่งที่ใช้กันทั่วไปเพื่อเป็นตัวอย่างของแนวคิดที่เรียบง่าย

ตอนนี้ถ้าคุณใช้ CPU 8 บิตเมื่อคุณเขียนไปยังหน่วยความจำคุณอาจพบข้อ จำกัด บางประการเกี่ยวกับความสามารถในการอ้างถึงที่อยู่ 8 บิตไม่ใช่ที่อยู่ 4 บิตหรือ 16 บิต รายละเอียดจะแตกต่างกันไปตามซีพียู แต่ถ้าคุณมีข้อ จำกัด เช่นนั้นซีพียูอาจมีคำศัพท์ 8 บิตซึ่งเป็นสาเหตุที่ทำให้ซีพียูมักถูกเรียกว่า "8 บิตซีพียู"