หลังจากหลายปีที่ผ่านมานี้ โลกยังคงขับเคลื่อนโดยการเขียนโปรแกรม C

โครงการ C หลายโครงการที่มีอยู่ในปัจจุบันเริ่มต้นขึ้นเมื่อหลายสิบปีก่อน

การพัฒนาระบบปฏิบัติการ UNIX เริ่มต้นในปี 1969 และโค้ดของมันถูกเขียนใหม่ในภาษา C ในปี 1972 จริงๆ แล้วภาษา C นั้นถูกสร้างขึ้นเพื่อย้ายโค้ดเคอร์เนล UNIX จากแอสเซมบลีไปยังภาษาระดับที่สูงกว่า ซึ่งจะทำงานแบบเดียวกันโดยมีโค้ดน้อยลง .

การพัฒนาฐานข้อมูล Oracle เริ่มต้นในปี 1977 และโค้ดของมันถูกเขียนใหม่จากแอสเซมบลีเป็น C ในปี 1983 กลายเป็นหนึ่งในฐานข้อมูลที่ได้รับความนิยมมากที่สุดในโลก

ในปี 1985 Windows 1.0 เปิดตัว แม้ว่าซอร์สโค้ดของ Windows จะไม่เปิดเผยต่อสาธารณะ แต่ก็มีการระบุว่าเคอร์เนลส่วนใหญ่เขียนด้วยภาษา C โดยมีบางส่วนอยู่ในแอสเซมบลี การพัฒนาเคอร์เนล Linux เริ่มต้นในปี 1991 และเขียนด้วยภาษา C เช่นกัน ในปีหน้า มันถูกเผยแพร่ภายใต้ลิขสิทธิ์ GNU และใช้เป็นส่วนหนึ่งของระบบปฏิบัติการ GNU ระบบปฏิบัติการ GNU นั้นเริ่มต้นโดยใช้ภาษา C และ Lisp ดังนั้นส่วนประกอบจำนวนมากจึงถูกเขียนด้วยภาษา C

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

โลกขับเคลื่อนโดย C อย่างไร?

แม้จะมีความแพร่หลายของภาษาระดับสูง แต่ C ยังคงเพิ่มพลังให้กับโลก ต่อไปนี้คือระบบบางระบบที่คนนับล้านใช้และตั้งโปรแกรมด้วยภาษา C

Microsoft Windows

เคอร์เนล Windows ของ Microsoft ได้รับการพัฒนาเป็นส่วนใหญ่ในภาษา C โดยมีบางส่วนเป็นภาษาแอสเซมบลี เป็นเวลาหลายทศวรรษแล้วที่ระบบปฏิบัติการที่ใช้มากที่สุดในโลก ซึ่งมีส่วนแบ่งการตลาดประมาณ 90 เปอร์เซ็นต์ ได้รับการขับเคลื่อนโดยเคอร์เนลที่เขียนด้วยภาษาซี

ลินุกซ์

Linux ส่วนใหญ่เขียนด้วยภาษา C โดยมีบางส่วนอยู่ในการประกอบ ประมาณ 97 เปอร์เซ็นต์ของซูเปอร์คอมพิวเตอร์ที่ทรงพลังที่สุดในโลก 500 ตัวรันเคอร์เนล Linux มันยังใช้ในคอมพิวเตอร์ส่วนบุคคลจำนวนมาก

Mac

คอมพิวเตอร์ Mac ยังขับเคลื่อนโดย C เนื่องจากเคอร์เนล OS X ส่วนใหญ่เขียนด้วยภาษา C ทุกโปรแกรมและไดรเวอร์ใน Mac เช่นเดียวกับในคอมพิวเตอร์ Windows และ Linux กำลังทำงานบนเคอร์เนลที่ขับเคลื่อนด้วย C

มือถือ

เคอร์เนล iOS, Android และ Windows Phone นั้นเขียนด้วยภาษาซีเช่นกัน พวกเขาเป็นเพียงการดัดแปลงอุปกรณ์พกพาของเคอร์เนล Mac OS, Linux และ Windows ที่มีอยู่ ดังนั้นสมาร์ทโฟนที่คุณใช้ทุกวันจึงทำงานบนเคอร์เนล C

ฐานข้อมูล

ฐานข้อมูลที่ได้รับความนิยมมากที่สุดในโลก รวมถึง Oracle Database, MySQL, MS SQL Server และ PostgreSQL ถูกเข้ารหัสด้วยภาษา C (ซึ่งจริง ๆ แล้ว 3 ฐานข้อมูลแรกนั้นมีทั้งในภาษา C และ C++)

ฐานข้อมูลถูกใช้ในทุกระบบ: การเงิน, รัฐบาล, สื่อ, ความบันเทิง, โทรคมนาคม, สุขภาพ, การศึกษา, การค้าปลีก, โซเชียลเน็ตเวิร์ก, เว็บ และอื่นๆ

ภาพยนตร์ 3 มิติ

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

ระบบสมองกลฝังตัว

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

จากนั้นคุณเข้าไปในรถของคุณ หากมีคุณสมบัติดังต่อไปนี้ ยังตั้งโปรแกรมไว้ใน C:

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

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

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

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

ทำไมยังคงใช้ภาษาการเขียนโปรแกรม C?

ปัจจุบันมีภาษาโปรแกรมมากมายที่ช่วยให้นักพัฒนาสามารถทำงานได้อย่างมีประสิทธิภาพมากกว่าภาษาซีสำหรับโปรเจ็กต์ประเภทต่างๆ มีภาษาระดับสูงกว่าซึ่งมีไลบรารีในตัวที่มีขนาดใหญ่กว่ามาก ซึ่งช่วยลดความยุ่งยากในการทำงานกับ JSON, XML, UI, หน้าเว็บ, คำขอของไคลเอ็นต์, การเชื่อมต่อฐานข้อมูล, การจัดการสื่อ และอื่นๆ

แต่ถึงอย่างนั้น ก็มีเหตุผลมากมายที่เชื่อได้ว่าการเขียนโปรแกรม C จะยังคงทำงานอยู่เป็นเวลานาน

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

การพกพาและประสิทธิภาพ

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

นั่นคือความสามารถในการพกพาและประสิทธิภาพที่ “คอมไพเลอร์ ไลบรารี และล่ามของภาษาโปรแกรมอื่น ๆ มักถูกนำไปใช้ในภาษาซี” ภาษาที่ตีความ เช่น Python, Ruby และ PHP มีการใช้งานหลักที่เขียนด้วยภาษา C ซึ่งใช้โดยคอมไพเลอร์สำหรับภาษาอื่นๆ เพื่อสื่อสารกับเครื่อง ตัวอย่างเช่น C เป็นภาษากลางที่อยู่ภายใต้ไอเฟลและฟอร์ธ ซึ่งหมายความว่าแทนที่จะสร้างรหัสเครื่องสำหรับทุกสถาปัตยกรรมที่จะได้รับการสนับสนุน คอมไพเลอร์สำหรับภาษาเหล่านั้นเพียงแค่สร้างรหัส C ระดับกลาง และคอมไพเลอร์ C จะจัดการการสร้างรหัสเครื่อง

C ได้กลายเป็น ภาษากลาง สำหรับการสื่อสารระหว่างนักพัฒนา อย่างที่อเล็กซ์ อัลเลน ผู้จัดการฝ่ายวิศวกรรมของ Dropbox และผู้สร้าง Cprogramming.com กล่าวไว้ว่า:

C เป็นภาษาที่ยอดเยี่ยมในการแสดงความคิดทั่วไปในการเขียนโปรแกรมในแบบที่คนส่วนใหญ่คุ้นเคย ยิ่งไปกว่านั้น หลักการมากมายที่ใช้ในภาษา C เช่น argc และ argv สำหรับพารามิเตอร์บรรทัดคำสั่ง ตลอดจนโครงสร้างลูปและประเภทตัวแปร จะแสดงในภาษาอื่นๆ มากมายที่คุณเรียนรู้ ดังนั้นคุณจะสามารถพูดได้ แก่ผู้คนแม้ว่าพวกเขาจะไม่รู้จัก C ในแบบที่เป็นเรื่องธรรมดาสำหรับคุณทั้งคู่

การจัดการหน่วยความจำ

การเข้าถึงที่อยู่หน่วยความจำโดยพลการและเลขคณิตของตัวชี้เป็นคุณลักษณะสำคัญที่ทำให้ C เหมาะสมอย่างยิ่งกับการ เขียนโปรแกรมระบบ (ระบบปฏิบัติการและระบบฝังตัว)

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

ไมโครคอนโทรลเลอร์สามารถออกแบบสถาปัตยกรรมได้ ตัวอย่างเช่น ไบต์ในที่อยู่หน่วยความจำ 0x40008000 จะถูกส่งโดย ตัวรับ/ส่งสัญญาณแบบอะซิงโครนัสสากล (หรือ UART ซึ่งเป็นส่วนประกอบฮาร์ดแวร์ทั่วไปสำหรับการสื่อสารกับอุปกรณ์ต่อพ่วง) ทุกครั้งที่ตั้งค่าบิตหมายเลข 4 ของที่อยู่ 0x40008001 เป็น 1 และหลังจากที่คุณตั้งค่าบิตนั้นแล้ว อุปกรณ์ต่อพ่วงจะยกเลิกการตั้งค่าโดยอัตโนมัติ

นี่จะเป็นรหัสสำหรับฟังก์ชัน C ที่ส่งไบต์ผ่าน UART นั้น:

 #define UART_BYTE *(char *)0x40008000 #define UART_SEND *(volatile char *)0x40008001 |= 0x08 void send_uart(char byte) { UART_BYTE = byte; // write byte to 0x40008000 address UART_SEND; // set bit number 4 of address 0x40008001 }

บรรทัดแรกของฟังก์ชันจะขยายเป็น:

 *(char *)0x40008000 = byte;

บรรทัดนี้บอกให้คอมไพเลอร์ตีความค่า 0x40008000 เป็นตัวชี้ไปยัง a char จากนั้นจึงทำการ dereference (ให้ค่าที่ชี้ไป) ตัวชี้นั้น (ด้วยตัวดำเนินการ * ซ้ายสุด) และสุดท้ายให้กำหนดค่า byte ให้กับตัวชี้ที่ไม่ได้อ้างอิงนั้น กล่าวอีกนัยหนึ่ง: เขียนค่าของตัวแปร byte ไปยังที่อยู่หน่วยความจำ 0x40008000

บรรทัดถัดไปจะขยายเป็น:

 *(volatile char *)0x40008001 |= 0x08;

ในบรรทัดนี้ เราดำเนินการระดับบิต OR กับค่าตามที่อยู่ 0x40008001 และค่า 0x08 ( 00001000 ในรูปแบบไบนารี นั่นคือ 1 ในบิตหมายเลข 4) และบันทึกผลลัพธ์กลับไปยังที่อยู่ 0x40008001 กล่าวอีกนัยหนึ่ง: เราตั้งค่าบิต 4 ของไบต์ที่อยู่ 0x40008001 นอกจากนี้เรายังประกาศด้วยว่าค่าที่อยู่ 0x40008001 มี ความผันผวน สิ่งนี้บอกคอมไพเลอร์ว่าค่านี้อาจได้รับการแก้ไขโดยกระบวนการภายนอกโค้ดของเรา ดังนั้นคอมไพเลอร์จะไม่ตั้งสมมติฐานใดๆ เกี่ยวกับค่าในที่อยู่นั้นหลังจากเขียนถึงมัน (ในกรณีนี้ บิตนี้ไม่ได้ตั้งค่าโดยฮาร์ดแวร์ UART หลังจากที่เราตั้งค่าด้วยซอฟต์แวร์) ข้อมูลนี้มีความสำคัญต่อเครื่องมือเพิ่มประสิทธิภาพของคอมไพเลอร์ หากเราทำสิ่งนี้ในลูป for ตัวอย่างเช่น โดยไม่ระบุว่าค่ามีความผันผวน คอมไพเลอร์อาจถือว่าค่านี้ไม่เปลี่ยนแปลงหลังจากตั้งค่าแล้ว และข้ามการดำเนินการคำสั่งหลังจากวนซ้ำครั้งแรก

การกำหนดการใช้ทรัพยากร

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

ขนาดรหัส

C มีรันไทม์น้อยมาก และรอยเท้าหน่วยความจำสำหรับโค้ดนั้นเล็กกว่าภาษาอื่นๆ ส่วนใหญ่

ตัวอย่างเช่น เมื่อเปรียบเทียบกับ C++ ไบนารีที่สร้าง C ที่ไปยังอุปกรณ์ฝังตัวจะมีขนาดประมาณครึ่งหนึ่งของไบนารีที่สร้างโดยโค้ด C++ ที่คล้ายกัน สาเหตุหลักประการหนึ่งคือการสนับสนุนข้อยกเว้น

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

มาดูตัวอย่างใน C++:

 // Class A declaration. Methods defined somewhere else; class A { public: A(); // Constructor ~A(); // Destructor (called when the object goes out of scope or is deleted) void myMethod(); // Just a method }; // Class B declaration. Methods defined somewhere else; class B { public: B(); // Constructor ~B(); // Destructor void myMethod(); // Just a method }; // Class C declaration. Methods defined somewhere else; class C { public: C(); // Constructor ~C(); // Destructor void myMethod(); // Just a method }; void myFunction() { A a; // Constructor aA() called. (Checkpoint 1) { B b; // Constructor bB() called. (Checkpoint 2) b.myMethod(); // (Checkpoint 3) } // b.~B() destructor called. (Checkpoint 4) { C c; // Constructor cC() called. (Checkpoint 5) c.myMethod(); // (Checkpoint 6) } // c.~C() destructor called. (Checkpoint 7) a.myMethod(); // (Checkpoint 8) } // a.~A() destructor called. (Checkpoint 9)

เมธอดของคลาส A , B และ C ถูกกำหนดไว้ที่อื่น (เช่น ในไฟล์อื่น) ดังนั้นคอมไพเลอร์จึงไม่สามารถวิเคราะห์ได้และไม่รู้ว่าจะมีข้อยกเว้นหรือไม่ ดังนั้นจึงต้องเตรียมรับมือกับข้อยกเว้นที่เกิดจากตัวสร้าง ตัวทำลาย หรือการเรียกใช้เมธอดอื่นๆ Destructors ไม่ควรโยน (การปฏิบัติที่แย่มาก) แต่ผู้ใช้สามารถโยนต่อไปหรือพวกเขาสามารถส่งทางอ้อมได้โดยการเรียกใช้ฟังก์ชันหรือวิธีการบางอย่าง (โดยชัดแจ้งหรือโดยปริยาย) ที่ทำให้เกิดข้อยกเว้น

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

 // Possible autogenerated function void autogeneratedStackUnwindingFor_myFunction(int checkpoint) { switch (checkpoint) { // case 1 and 9: do nothing; case 3: b.~B(); goto destroyA; // jumps to location of destroyA label case 6: c.~C(); // also goes to destroyA as that is the next line destroyA: // label case 2: case 4: case 5: case 7: case 8: a.~A(); } }

หากมีข้อยกเว้นจากจุดตรวจ 1 และ 9 จะไม่มีวัตถุใดที่จำเป็นต้องทำลาย สำหรับด่าน 3 b และ a จะต้องถูกทำลาย สำหรับด่าน 6 c และ a จะต้องถูกทำลาย ต้องเคารพลำดับการทำลายล้างในทุกกรณี สำหรับด่านที่ 2, 4, 5, 7 และ 8 จะต้องทำลายเฉพาะวัตถุ a เท่านั้น

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

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

เหตุผลในการเรียนรู้ C

ภาษาซีไม่ใช่ภาษาที่เรียนยาก ดังนั้นประโยชน์ทั้งหมดจากการเรียนรู้จึงค่อนข้างถูก เรามาดูประโยชน์เหล่านั้นกันบ้าง

Lingua Franca

ดังที่ได้กล่าวไปแล้ว C เป็น ภาษากลาง สำหรับนักพัฒนา การนำอัลกอริธึมใหม่ๆ ไปใช้ในหนังสือหรือบนอินเทอร์เน็ตเป็นอันดับแรก (หรือเท่านั้น) ที่ผู้เขียนจัดทำขึ้นในภาษา C นี้จะช่วยให้พกพาสูงสุดที่เป็นไปได้สำหรับการใช้งาน ฉันเคยเห็นโปรแกรมเมอร์ดิ้นรนบนอินเทอร์เน็ตเพื่อเขียนอัลกอริธึม C ใหม่เป็นภาษาโปรแกรมอื่น เพราะเขาหรือเธอไม่รู้แนวคิดพื้นฐานของ C

โปรดทราบว่า C เป็นภาษาที่เก่าและแพร่หลาย ดังนั้นคุณจึงสามารถค้นหาอัลกอริธึมทุกประเภทที่เขียนด้วยภาษา C ได้ทั่วทั้งเว็บ ดังนั้น คุณจะได้รับประโยชน์อย่างมากจากการรู้ภาษานี้

เข้าใจเครื่อง (คิดใน C)

เมื่อเราพูดถึงพฤติกรรมของโค้ดบางส่วนหรือคุณลักษณะบางอย่างของภาษาอื่นๆ กับเพื่อนร่วมงาน เราจะ "พูดในภาษา C:" ส่วนนี้ส่ง "ตัวชี้" ไปยังวัตถุหรือคัดลอกวัตถุทั้งหมดหรือไม่ มี "นักแสดง" เกิดขึ้นที่นี่หรือไม่? และอื่นๆ.

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

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

ทำงานในโครงการ C ที่น่าสนใจมากมาย

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

บทสรุป

ภาษาโปรแกรม C ดูเหมือนจะไม่มีวันหมดอายุ ความใกล้ชิดกับฮาร์ดแวร์ การพกพาที่ดีเยี่ยม และการใช้ทรัพยากรที่กำหนดได้ชัดเจน ทำให้เหมาะอย่างยิ่งสำหรับการพัฒนาระดับต่ำสำหรับสิ่งต่างๆ เช่น เคอร์เนลของระบบปฏิบัติการและซอฟต์แวร์ฝังตัว ความเก่งกาจ ประสิทธิภาพ และประสิทธิภาพที่ดีทำให้เป็นตัวเลือกที่ยอดเยี่ยมสำหรับซอฟต์แวร์จัดการข้อมูลที่มีความซับซ้อนสูง เช่น ฐานข้อมูลหรือแอนิเมชั่น 3 มิติ ความจริงที่ว่าภาษาเขียนโปรแกรมจำนวนมากในปัจจุบันดีกว่า C สำหรับการใช้งานที่ตั้งใจไว้ไม่ได้หมายความว่าจะเอาชนะ C ได้ในทุกด้าน C ยังคงไม่มีใครเทียบได้เมื่อประสิทธิภาพเป็นสิ่งสำคัญ

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