สวัสดีและยินดีต้อนรับกลับ
ในการบรรยายครั้งนี้ ฉันต้องการ เพื่อพูดคุยเกี่ยวกับสิ่งที่จะเกิดขึ้นในการสร้างโปรแกรมภาษาซี
จึงมีงานพื้นฐานสี่ประการ ในการสร้างโปรแกรมภาษาซีใดๆ
และงานเหล่านี้คืออะไร รวมถึงการแก้ไข รวบรวม เชื่อมโยง
และดำเนินการ
เราคุยกันถึงขั้นตอนต่างๆ ที่คุณจะใช้เมื่อคุณเขียนโปรแกรมภาษาซีในแง่ของคุณกำลังจะไป
เพื่อทำความเข้าใจข้อกำหนด คุณจะต้องออกแบบโค้ดของคุณ คุณ กำลังจะเขียนโค้ดของคุณ
จากนั้นคุณจะทดสอบและดีบั๊กมัน และอื่นๆ แล้วรักษาไว้
ที่ฉันกำลังพูดถึงนี่คือสิ่งที่ คุณต้องทำจริง ๆ เมื่อคุณเริ่มเขียนโปรแกรม
เราก็คุยกัน
เกี่ยวกับการแก้ไข การคอมไพล์ แต่การลิงก์และการดำเนินการก็มีความสำคัญเช่นกัน
และเรื่องที่อยากคุย นี่คือรายละเอียดของสิ่งนี้
ดังนั้นงานเหล่านี้จึงกลายเป็น ธรรมชาติที่สองสำหรับคุณเพราะคุณกำลังจะทำมัน
ทุกครั้งที่คุณเขียนโปรแกรมภาษาซี
คุณกำลังจะทำการแก้ไข . ของคุณ ซอร์สโค้ด
คุณกำลังคอมไพล์ คุณกำลังลิงก์ แล้วคุณก็จะวิ่งไป
คุณกำลังจะทำ นี้บ่อยมาก
ดังนั้นขั้นตอนการแก้ไข การคอมไพล์ การเชื่อมโยง และการดำเนินการนั้นเหมือนกันสำหรับการพัฒนา
โปรแกรมในทุกสภาพแวดล้อมด้วยภาษาที่คอมไพล์แล้ว
นี่ไม่ใช่เรื่องเฉพาะสำหรับค.
หากคุณกำลังเขียน java - java โปรแกรม, คุณจะเขียนซอร์สโค้ด,
คุณจะไป เพื่อรวบรวมซอร์สโค้ด
กำลังเชื่อมโยง - คุณอาจไม่รู้เท่าทัน ของใน java แต่จะทำการเชื่อมโยงบางอย่างและเราจะพูดคุย
เกี่ยวกับการเชื่อมโยงคืออะไร แล้วคุณจะเรียกใช้โปรแกรม
คุณจะทำทั้งหมดนี้
ที่ฉันกำลังอธิบายอยู่นี้ อีกครั้งคือวิธีการทำในค.
ดังนั้นการแก้ไขจึงเป็นสิ่งที่ คุณจะคิดว่ามันเป็น
เป็นกระบวนการสร้าง และแก้ไขโค้ดจริง
ซอร์สโค้ด c
ซอร์สโค้ด c กำลังดำเนินการ ที่จะอยู่ภายในไฟล์.
และมันจะมีทั้งหมด คำสั่งและคำแนะนำทั้งหมดที่คุณเขียน
ไฟล์ซอร์สโค้ด c ทั้งหมดสิ้นสุด กับ . นามสกุล c และนั่นคือวิธีที่คุณสามารถระบุได้
ว่าเป็นไฟล์ซอร์สโค้ด
ก่อนหน้านั้น . c ส่วนขยายกำลังจะไป หากต้องการเรียกชื่อฐาน
คุณต้องการให้ชื่อไฟล์ของคุณมีความหมาย
ถ้าคุณเขียนโปรแกรมภาษาซีที่บวกสอง คุณอาจจะมีไฟล์ชื่อ
add c ที่มีซอร์สโค้ด
และจำไว้ว่าส่วนใหญ่ค โปรแกรมจะมีไฟล์ต่างๆ
มากมาย
ดังนั้นไฟล์ของคุณควรมีชื่อที่ดี
แต่วิธีที่คุณสามารถระบุได้ ซอร์สโค้ด c คือ . ค ส่วนขยาย
พวกเขาทั้งหมดมี. ค ส่วนขยาย
ตอนนี้เมื่อเราแก้ไขรหัสของเราสำหรับ คลาสนี้ เราจะใช้สภาพแวดล้อมการพัฒนาแบบบูรณาการ
เราไม่ได้แค่ไป เพื่อใช้ตัวแก้ไขอย่างง่าย
ตัวอย่างของเครื่องมือแก้ไขอย่างง่าย น่าจะเป็น wordpad
เราจะใช้อะไรบางอย่าง ที่มีตัวแก้ไขแต่ยังมีอีกหลายอย่างที่ช่วยคุณได้
เขียนโค้ดของคุณอย่างมีประสิทธิภาพมากขึ้น
IDE - และสิ่งนี้เรียกว่า IDE สภาพแวดล้อมการพัฒนาแบบบูรณาการ
ที่เราจะใช้กัน สำหรับคลาสนี้คือ Code
Blocks ฉันจะอธิบายโดยละเอียด แต่เราจะใช้บล็อคโค้ดสำหรับงานแก้ไข
แต่คุณสามารถใช้สิ่งที่คุณต้องการ
หากคุณต้องการใช้แผ่นจดบันทึก ถ้าคุณ
อยากใช้ของจิ๋วกว่านี้ก็ได้ อะตอม ก็มี visual studio IDEs แต่สิ่งที่เรากำลังจะพูดถึงในที่นี้คือวิธีการ
เพื่อแก้ไขโค้ดและบล็อคโค้ดของคุณ
และนี่เป็นความคิดที่ดีและ เหตุผลที่ฉันเลือกเราจะพูดถึงรายละเอียดเพิ่มเติม
แต่มันคือ ข้ามแพลตฟอร์มและใช้งานง่าย
ดังนั้นการแก้ไขจึงเป็นพื้นฐาน กระบวนการเขียนรหัส
กำลังรวบรวม
เรารู้ว่าคอมไพเลอร์ทำอะไร
มันต้องใช้ระดับสูงเท่านั้น รหัสภาษาและแปลงเป็นภาษาเครื่องและมันยัง
ตรวจพบและพบข้อผิดพลาดในรหัสของคุณ
หลังจากที่คุณแก้ไขรหัสของคุณ คุณจะ กำลังจะรันคอมไพเลอร์
ดังนั้นอินพุตของคอมไพเลอร์คือ จะเป็นซอร์สโค้ดทั้งหมดของคุณ
ไฟล์ . ไฟล์ c ทุกสิ่งที่คุณกำลังแก้ไข
และอีกครั้ง โปรแกรม a c สามารถ มีไฟล์ต้นฉบับจำนวนมาก
แต่อินพุตของคอมไพเลอร์คือ ไฟล์ต้นฉบับเหล่านี้รวบรวมตัวเองแปลงรหัสนี้
เป็นกระบวนการสองขั้นตอน
ขั้นแรกเรียกว่า ขั้นตอนก่อนการประมวลผล
ในระหว่างที่รหัสของคุณอาจ จะแก้ไขหรือเพิ่มเข้าไป
และขั้นที่สองคือ การคอมไพล์จริงจะสร้างรหัสภาษาแอสเซมบลี
และเราจะพูดถึงเรื่องนี้กันมากขึ้น รายละเอียด ขั้นตอนก่อนการประมวลผลนี้
แต่แค่ต้องรู้ ตอนนี้มีสองขั้นตอนเมื่อคุณรวบรวม
ที่พวกเราจะให้ความสำคัญ หรือสิ่งที่เข้าใจได้ง่ายคือการสร้างรหัสวัตถุ
ดังนั้นคอมไพเลอร์จะไป ดูแต่ละประโยคแล้วทำให้แน่ใจได้ว่า
ไวยากรณ์ถูกต้องและตรงกับความหมายของภาษา
วากยสัมพันธ์คือการทำให้แน่ใจว่า โครงสร้างของรหัสถูกต้อง
ที่คุณมีอัฒภาคที่ ท้ายประโยค ว่าคุณกำลังใช้ประเภทข้อมูล
ที่คุณ - คุณ ตามกฎของภาษา
ความหมายคือความหมายของคำ
ดังนั้นหากคุณใช้ if คีย์เวิร์ด นั่นคือเงื่อนไข
ความหมายเกิดขึ้นใน ขั้นตอนการคอมไพล์โดยการสร้างตารางสัญลักษณ์และอื่นๆ
แต่คอมไพเลอร์มีความสำคัญ
กำลังจะเกิดขึ้น รหัสวัตถุนี้
มันจะบอกคุณถ้าคุณ มีข้อผิดพลาดในไวยากรณ์ของคุณ
บางครั้งก็รับรู้ได้ คุณมีโค้ดที่ไม่ทำงานซึ่งโดยพื้นฐานแล้วไม่ได้ใช้โค้ดหรือไม่
ไม่พบข้อผิดพลาดทางตรรกะ
พบข้อผิดพลาดทางไวยากรณ์เท่านั้น
อีกครั้ง ไวยากรณ์คือ กฎและภาษา
ข้อผิดพลาดทางตรรกะคือความหมาย
เช่นถ้าคุณทำผิดพลาด ในทางตรรกะ คุณอาจทำผิดพลาดในการทำงาน
เพื่อให้โค้ดของคุณสามารถรัน คอมไพล์ได้ แต่อาจไม่ทำงานตามที่ตั้งใจไว้ และสิ่งนี้เรียกว่าข้อผิดพลาดทางตรรกะ
คอมไพเลอร์จะไม่บอก คุณถ้าคุณมีข้อผิดพลาดทางตรรกะ
หากคุณตั้งใจจะขอ a . จากผู้ใช้ ตัวเลขแทนสตริงอักขระหรือคุณขอให้ผู้ใช้ใช้ตัวสุดท้าย ชื่อก่อนชื่อของพวกเขาที่เป็นข้อผิดพลาดทางตรรกะ
คอมไพเลอร์ไม่ทำงาน เพื่อบอกคุณถึงข้อผิดพลาดประเภทนั้น
ข้อผิดพลาดทั่วไปที่รายงานโดย คอมไพเลอร์จะเป็นเช่นตัวแปรที่ไม่ได้ประกาศ
expression ที่ไม่สอดคล้องกับวากยสัมพันธ์ คุณไม่มีสิทธิ์
ในวงเล็บ แสดงว่าคุณรู้จักบล็อกที่ไม่มีบล็อกสิ้นสุด
คุณจะกลายเป็นมาก, คุ้นเคยกับข้อผิดพลาดของคอมไพเลอร์และความหมาย
หวังว่าหลังจากที่คุณได้เรียนรู้ ภาษาซี และคุณรันคอมไพเลอร์
คุณจะเห็น ข้อผิดพลาดและคุณจะสามารถแก้ไขได้ทันที
บอกว่าอ๊ะลืมไวยากรณ์หรือ อุ๊ย ลืมเครื่องหมายอัฒภาค
โอ้ ฉันลืมให้สิทธิ์ วงเล็บเพื่อสิ้นสุดบล็อกของรหัสนั้น
มันจะกลายเป็นธรรมชาติที่สอง
ดังนั้นหลังจากที่คุณแก้ไขทั้งหมด ข้อผิดพลาดและการคอมไพล์ของคุณสำเร็จ
มันจะไป แปลเป็นภาษาแอสเซมบลีและสร้างโค้ดอ็อบเจ็กต์นี้
ดังนั้นวัตถุจริง รหัสคือ . o ไฟล์
มันคือบทสรุปที่แท้จริง รหัสภาษาที่เรียกใช้
มันมีนามสกุล . obj หรือ . o โดยทั่วไปแล้ว obj บน windows จะเป็นส่วนขยาย o บน Linux หรือ Macintosh ระบบจะเป็นส่วนขยาย
คุณจะเห็นไฟล์นั้น สร้างขึ้นหลังจากที่คุณรวบรวมรหัสของคุณ
และนั่นเป็นเพียงช่วงสุดท้าย ของการคอมไพล์
นั่นคือภาษาแอสเซมบลีที่แท้จริง
มันจะเป็นเลขฐานสอง มัน ดูเหมือนข้อความที่คุณจะดูไม่ได้
มันก็แค่จะมี . o ส่วนขยาย และนั่นคือสิ่งที่คอมไพเลอร์สร้างขึ้น
วิธีที่คุณรันคอมไพเลอร์ ใน c คือคุณใช้คำสั่งจริงๆ
คงไม่ต้องทำหรอกมั้ง
มากเพราะความคิด บรรณาธิการในการพัฒนาแบบบูรณาการคือ จะทำเพื่อคุณโดยเพียงแค่คลิกที่ตัวเลือกเมนู
แต่มันคือ สำคัญที่จะรู้ว่าเกิดอะไรขึ้น
ดังนั้นเมื่อคุณออกคอมไพเลอร์ คำสั่ง
โดยทั่วไปจะใช้คอมไพเลอร์ GNU ซึ่งเป็นคำสั่ง gcc
แต่ในระดับพื้นฐาน คุณก็แค่วิ่ง โปรแกรมคอมไพเลอร์ cc หรือ gcc
คุณเรียกใช้โปรแกรมนั้นและ จากนั้นคุณระบุอินพุต
จำไว้ว่าคอมไพเลอร์ใช้ เป็นอินพุตไฟล์ต้นฉบับ
คุณระบุอินพุตโดยใช้ a -c ตั้งค่าสถานะแล้วระบุไฟล์ต้นทางทีละไฟล์
ตัวอย่างที่นี่คือ cc-cmyprog ค หรือ หากคุณกำลังใช้คอมไพเลอร์ GNU ซึ่งเป็น
gcc-c ยอดนิยม
และถ้าคุณละเว้น c แฟล็ก your โปรแกรมจะถูกเชื่อมโยงโดยอัตโนมัติเช่นกันซึ่งเป็นขั้นตอนต่อไป
แต่วิ่งง่ายจริงๆ คอมไพเลอร์หากคุณอยู่ที่อินเทอร์เฟซบรรทัดคำสั่ง
มันง่ายยิ่งขึ้นถ้าคุณเพียงแค่ ใช้ตัวเลือกเมนูที่เราน่าจะทำในคลาสนี้
แต่มันกลับต้องใช้เวลา อินพุตไฟล์ต้นฉบับ c
ในบล็อคโค้ดดังที่ผมได้กล่าวไปแล้ว
คุณจะเพียงแค่คลิกตัวเลือกเมนูและมันจะ คอมไพล์ลิงค์อัตโนมัติแล้วคลิกเมนูอื่นได้เลย
ตัวเลือกจะทำงานโดยอัตโนมัติ
แต่อีกครั้งสิ่งที่เกิดขึ้นภายใต้ ประทุนคือคุณกำลังออกคำสั่งคอมไพเลอร์ด้วย
-c แฟล็กและไฟล์ต้นฉบับอินพุต
หลังจากที่คุณรวบรวม คุณเชื่อมโยง อย่างที่บอกไปว่าทุกภาษาโปรแกรมมีลิงค์แต่มีมาก บางครั้งก็โปร่งใส
คุณจะไม่รู้ด้วยซ้ำว่าเกิดอะไรขึ้น
ใน c กระบวนการเชื่อมโยงมีความสำคัญ เพราะมันไม่โปร่งใสเสมอไป
แต่ด้วย IDE ที่ทันสมัยที่สุดในปัจจุบัน
มันเป็น แต่ฉันต้องเน้นว่ามันมีความสำคัญในค.
ดังนั้นหลังจากที่โปรแกรมมี ได้รับการแปลเป็นนี้ รหัสเก่า รหัสวัตถุ it ก็พร้อมที่จะเชื่อมโยง
เหตุผลที่เราเชื่อมโยงคือถ้าเรา การใช้ห้องสมุดภายนอกเราต้องคว้าห้องสมุดอื่น
ๆ ทั้งหมด และรวมไว้ในโปรแกรมเดียว
ดังนั้นการเชื่อมโยงจึงเป็นเพียงแค่การรับทั้งหมด การพึ่งพาในสถานที่และสร้างไฟล์ปฏิบัติการจริง
ดังนั้น . o ไฟล์เป็นวัตถุ
จากนั้นคุณเชื่อมโยง .ทั้งหมด . os เป็นไฟล์ปฏิบัติการเดียว
และอีกครั้ง ที่มักจะเป็น โปร่งใส
มักจะเกิดขึ้นโดยอัตโนมัติเมื่อคุณคอมไพล์
แต่อีกครั้งอาจไม่ใช่และ คุณอาจต้องทำคำสั่งแยกต่างหาก
เช่น -l หรืออย่างอื่น
แต่มันใช้วัตถุเหล่านั้นทั้งหมด ไฟล์และสร้างไฟล์ปฏิบัติการได้
และไฟล์ปฏิบัติการคือสิ่งที่คุณเรียกใช้
มันจะรวมสิ่งเหล่านั้นเข้าด้วยกัน
แล้วมันก็ไปรวมกัน
และคุณอาจมี ระบบปฏิบัติการที่เป็น ไลบรารีเพิ่มเติม ที่โปรแกรมอื่น ๆ ที่คุณอาจต้องการใช้นั้น
คนอื่นเขียนหรือห้องสมุดอื่น ๆ
ที่มาพร้อมกับภาษาซี
คุณจะเอาทั้งหมด เหล่านั้นและประกอบเข้าด้วยกัน
และเฟสเชื่อมโยงจะ ยังตรวจจับและรายงานข้อผิดพลาด
พวกเขาเป็นสองขั้นตอนที่แยกจากกัน
การเชื่อมโยงอีกครั้งมักจะเป็นเช่น ข้อผิดพลาดในการกำหนดใหม่หรือคุณกำลังพยายามเรียกใช้ฟังก์ชันที่ไม่มีอยู่
ดังนั้นหากคุณไม่มีสิ่งนั้น o ไฟล์ถึง ประกอบเป็นโปรแกรมทั้งหมด คุณจะมีข้อผิดพลาดในการเชื่อมโยง
และคุณจะต้องมีทั้งหมด . โอ.
และอีกครั้งที่. o's อาจไม่ใช่ของคุณด้วยซ้ำ
อาจมาพร้อมภาษาเดียวกัน อาจเป็นส่วนหนึ่งของห้องสมุดมาตรฐานหรืออาจมาพร้อมกับห้องสมุดอื่น
โปรแกรมที่คนอื่นเขียน
แต่คุณต้องการสิ่งเหล่านั้นทั้งหมด o's เพื่อสร้างไฟล์ปฏิบัติการ
ดังนั้นไลบรารีโปรแกรมจึงรองรับและ ขยายภาษา C โดยจัดให้มีรูทีนเพื่อดำเนินการ
ที่ไม่ใช่ส่วนหนึ่งของภาษา
ไลบรารีอินพุตและเอาต์พุตคือ ตัวอย่าง ห้องสมุดคณิตศาสตร์
ห้องสมุดการจัดการสตริง
นี่เป็นเพียงสิ่งเดียวกันถ้าคุณ คุ้นเคยกับโปรแกรมจาวา
มันเหมือนกับจาวา api
มันเหมือนกับแพ็คเกจ
มันเป็นแนวคิดของฉันต้องการ
เขียนข้อมูลลงในไฟล์ ฉันไม่ต้องการที่จะใช้มันเอง
ฉัน จะใช้ห้องสมุดที่มีอยู่ซึ่งมาพร้อมกับภาษา
มันยังคงเขียนใน c มันคือ แค่ใครสักคนที่มาพร้อมกับสิ่งนั้น
มีทุกประเภท
ไลบรารีต่างๆ ที่เราจะเรียนรู้และใช้งาน
สิ่งนี้เกิดขึ้นส่วนหนึ่งของ ขั้นตอนการเชื่อมโยง
ดังนั้นความล้มเหลวระหว่างขั้นตอนการเชื่อมโยง
หมายความว่าคุณต้องกลับไปแก้ไขซอร์สโค้ดของคุณอีกครั้งเพื่อสร้าง
แน่ใจว่าคุณหาไฟล์อ็อบเจ็กต์นั้นเจอได้ ดังนั้นจึงมักมีความล้มเหลวมากมาย
หมายความว่าคุณเพียงแค่ต้องใส่ไฟล์หรืออะไรทำนองนั้น นี้ ก็จะกลายเป็นธรรมชาติที่สองเช่นกัน
สำเร็จถ้าคุณทำเสร็จแล้ว คอมไพล์สำเร็จแล้ว ลิงค์สำเร็จแล้ว
จะสร้างไฟล์ปฏิบัติการ
ในสภาพแวดล้อมของ windows ไฟล์ปฏิบัติการจะมีนามสกุล
. นามสกุล .exe
ใน Linux และ Windows มันจะ เพียงแค่มีโดยค่าเริ่มต้น ออก.
คุณสามารถเปลี่ยนชื่อของ ออก กับสิ่งที่มีความหมายมากขึ้นโดยเพียงแค่ออกบางสิ่งบางอย่างตาม
ด้วยคำสั่งคอมไพเลอร์
แต่ IDE ส่วนใหญ่ในบล็อคโค้ดก็เช่นกัน
จะมีคอมไพล์และลิงค์โปรแกรมในการดำเนินการเดียวและจะ
สร้างไฟล์ปฏิบัติการ จากนั้นคุณสามารถดับเบิลคลิกที่ไฟล์ปฏิบัติการได้ หรือคุณสามารถเรียกใช้ปฏิบัติการได้จากคำสั่งหรือจากตัวเลือกเมนู
แต่ไม่ใช่ในระดับต่ำถ้าคุณ บน Linux
คุณจะเห็น a. โดยค่าเริ่มต้นเป็นไฟล์ปฏิบัติการของคุณ บน windows คุณจะเห็นไฟล์ . exe.
โปรแกรมที่มีขนาดสำคัญ จะประกอบด้วยไฟล์ซอร์สโค้ดหลายไฟล์ ที่ผมกล่าวถึงก่อนหน้านี้
ไฟล์ซอร์สโค้ดแต่ละไฟล์ต้องการ คอมไพเลอร์เพื่อสร้างไฟล์อ็อบเจ็กต์ที่ต้องเชื่อมโยง
โปรแกรมนี้ง่ายกว่ามากในการ จัดการโดยแบ่งออกเป็นไฟล์ต้นฉบับที่มีขนาดเล็กกว่าจำนวนหนึ่ง
คุณจะต้องการใช้แหล่งที่มามากมาย ไฟล์ และคุณไม่ต้องการให้ไฟล์ต้นฉบับมีโค้ด
5,000 บรรทัด
ที่ไม่เหนียวแน่น
ไม่ใช่เรื่องง่ายในการจัดการ
ดังนั้นคุณกำลังจะสร้างไฟล์ ที่มีซอร์สโค้ด
และซอร์สโค้ดจะเป็นแบบเฉพาะเจาะจง
มันจะมี ฟังก์ชั่นเฉพาะ
มันทำให้ง่ายขึ้นมากที่จะ พัฒนาและดีบักได้ง่ายขึ้นและมีความเหนียวแน่นมากขึ้น
แล้วคุณจะมี ไฟล์ต้นฉบับที่มีขนาดเล็กกว่าจำนวนมาก
คุณไม่ต้องการไฟล์ต้นฉบับขนาดใหญ่ ด้วยโค้ดนับพันบรรทัด
และไฟล์ต้นฉบับทั้งหมดเหล่านี้คือ จะทำขึ้นทั้งโปรแกรม
พวกเขาทั้งหมดจะมีของพวกเขา เป็นเจ้าของ . o และพวกมันทั้งหมดจะถูกป้อนเข้าสู่คอมไพเลอร์
แนวคิดทั้งหมดนี้ทำให้ ขึ้นโปรแกรมเป็นหลักก็ถือว่าเป็นโครงการ
คุณสามารถคิดว่ามันเป็น ในระดับที่สูงขึ้น
มันคือโครงการของคุณ มันคือโปรแกรมของคุณ
หลังจากคุณทำทุกอย่างเสร็จแล้ว สิ่งนี้และคุณได้เชื่อมโยงแล้ว คุณมีไฟล์ปฏิบัติการของคุณ
จากนั้นคุณสามารถรันโปรแกรมได้
ใน IDE ส่วนใหญ่ นี่เป็นเพียง จะเป็นการคลิกเมนูหรือคุณสามารถดับเบิลคลิกในหน้าต่าง
คุณสามารถดับเบิลคลิกที่ exe
และถ้าคุณใช้ลินุกซ์ คุณเพียงแค่พิมพ์ใน ออก.
ตอนนี้เมื่อก. ออกคุณต้องมี สิทธิ์บางอย่างดังนั้นคุณอาจต้องออกคำสั่งโหมดเปลี่ยน
แต่การเรียกใช้คุณสามารถพูดได้ /ก. ออกและที่จะเรียกใช้โปรแกรม
จากบรรทัดคำสั่ง Linux
แต่โดยปกติคุณไม่จำเป็นต้อง กังวลเกี่ยวกับเรื่องนี้ ดังนั้นขั้นตอนการดำเนินการคือที่ที่คุณเรียกใช้โปรแกรมของคุณ
งบแต่ละโปรแกรม จะถูกดำเนินการตามลำดับ
หากโปรแกรมร้องขอใดๆ ข้อมูลจากผู้ใช้
โปรแกรมจะหยุดชั่วคราวและรับข้อมูลเข้านั้น
คุณสามารถรับอินพุตได้ทาง แป้นพิมพ์หรือสามารถรับอินพุตผ่านส่วนต่อประสานกราฟิกกับผู้ใช้หากคุณมี
ไลบรารีสำหรับสิ่งนั้นในรหัส c ของคุณ
ผลลัพธ์ที่แสดง โดยโปรแกรมจะปรากฏในหน้าต่างที่เรียกว่าคอนโซล
และเราจะแสดง คุณยกตัวอย่างเมื่อเราพูดถึงการบล็อกโค้ด
แต่เมื่อคุณรันโปรแกรมของคุณ โดยปกติคุณจะเห็นผลลัพธ์
ไม่เสมอไป บางครั้งโปรแกรมก็จะ ทำในสิ่งที่ไม่ได้ผลิตผล
แต่โดยปกติ พวกมันให้ผลผลิต และคุณเห็นเอาต์พุตบนเทอร์มินัลหรือคอนโซล
ขั้นตอนการดำเนินการยังสร้าง เงื่อนไขข้อผิดพลาดที่หลากหลาย
ดังนั้นคุณอาจผลิตผิด เอาต์พุตซึ่งเป็นเพียงข้อผิดพลาดทางตรรกะและคุณต้องย้อนกลับ
และแก้ไขซอร์สโค้ดของคุณ
อาจนั่งเฉยๆไม่ทำอะไรเลย เพราะคุณมีปัญหาทางตรรกะ
แล้วสุดท้ายก็พังได้ คอมพิวเตอร์ของคุณซึ่งเป็นกรณีที่เลวร้ายที่สุดซึ่งหมายความว่า
คุณทำบางอย่างที่แย่มากในรายการของคุณและมันแย่มาก ว่าโปรแกรมเพิ่งตายหรือเพียงแค่หรือมันทำให้เกิดอื่น ๆ โปรแกรมบนระบบปฏิบัติการของคุณเพื่อทำให้คอมพิวเตอร์ทั้งเครื่องพัง
ดังนั้นการรันแอปพลิเคชัน c จริง อาจทำให้เกิดปัญหาได้ หากโปรแกรมไม่ดำเนินการ ฟังก์ชั่นที่ตั้งใจไว้ จากนั้นคุณต้องกลับไปแก้ไขแหล่งที่มา
โค้ดที่คุณอาจต้องจัดระเบียบใหม่หรือออกแบบใหม่
และนี่คือที่ที่เรา กล่าวถึงขั้นตอนต่างๆ
สิ่งนี้เรียกว่าการดีบัก เฟสเพื่อค้นหาและแก้ไขข้อผิดพลาดของคุณ
เราจะมีกันถ้วนหน้า ส่วนเรื่องการดีบักเพราะมันเป็นสิ่งสำคัญ
ฉันได้กล่าวไว้ก่อนหน้านี้ว่าหนึ่ง วิธีที่ดีที่สุดที่จะเรียนรู้คือการเรียนรู้ผ่านข้อผิดพลาดของคุณ
คุณจะกลับไปอย่างต่อเนื่อง และแก้ไขซอร์สโค้ดและดีบัก
กระบวนการรวบรวมทั้งหมด เชื่อมโยงและรันโปรแกรมซ้ำ
ๆ จนกว่าคุณจะทำเสร็จ จนกว่าคุณจะ มีผลลัพธ์ทั้งหมดที่คุณต้องการสำหรับการทำงานของโค้ดนั้น
มาอีกแล้ว สวยๆอีกแล้ว ภาพประกอบฉันชอบที่จะให้
อันนี้เอามาจากหนังสือ เรียกว่า Beginning C โดย Horton
แต่นี่คือกระบวนการ ที่คุณจะมี
คุณจะแก้ไขซอร์สโค้ดของคุณ
คุณจะสร้างไฟล์ด้วย a . c นามสกุลและชื่อที่มีความหมาย
คุณจะใช้ตัวแก้ไข เพื่อทำสิ่งนั้นหรือ IDE สภาพแวดล้อมการพัฒนาแบบบูรณาการ
บางอย่างเช่น Code Blocks
จากนั้นคุณจะรวบรวมมัน
คอมไพเลอร์กำลังจะไป สร้างไฟล์ obj และไฟล์ o
ถ้ามันไม่สร้างไฟล์นั้น
นั่นหมายความว่าคุณมีข้อผิดพลาดและคุณต้องกลับไปแก้ไข
หลังจากที่คุณสร้างไฟล์ obj แล้ว ไฟล์อ็อบเจ็กต์คุณต้องเชื่อมโยงทั้งหมดเข้าด้วยกัน
เพื่อสร้างไฟล์ปฏิบัติการ
และคุณยังสามารถมี ข้อผิดพลาดในระยะนั้นที่ไม่ได้เชื่อมโยงอย่างถูกต้อง
คุณต้องกลับไปและ แก้ไขซอร์สโค้ดของคุณ
เมื่อคุณไม่มีข้อผิดพลาดจริงๆ และคุณมีไฟล์ปฏิบัติการ
จากนั้นคุณสามารถเรียกใช้โปรแกรมของคุณได้
และอีกครั้งหลังจากที่คุณเรียกใช้ โปรแกรม คุณยังอาจมีข้อผิดพลาดเนื่องจากอาจมีข้อผิดพลาดทางตรรกะ
แล้วคุณจะกลับไป และแก้ไขซอร์สโค้ดของคุณ
นี่จะกลายเป็น กระบวนการซ้ำๆ
ที่คุณจะคุ้นเคย
แก้ไข รวบรวม เชื่อมโยง ดำเนินการ
และนี่คืออีกครั้งโดยปกติ สิ่งที่คุณทำในทุกภาษา
คุณกำลังจะทำสิ่งนี้มากกว่าและ ซ้ำแล้วซ้ำอีกจนกว่าโปรแกรมของคุณจะตรงตามความต้องการทั้งหมดของคุณ