makepp_tutorial_compilation - ออนไลน์ใน Cloud

โครงการ:

ชื่อ

makepp_tutorial_compilation -- คำสั่งคอมไพล์ Unix

DESCRIPTION

ข้ามหน้าคู่มือนี้หากคุณเข้าใจดีว่าคำสั่งการคอมไพล์ทำอะไร

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

ตัวอย่างส่วนใหญ่จะใช้สำหรับ C เนื่องจากการรวบรวม C ++ จะเหมือนกันยกเว้นชื่อ
ของคอมไพเลอร์นั้นแตกต่างกัน สมมติว่าคุณกำลังรวบรวมซอร์สโค้ดในไฟล์ชื่อ
"xyz.c" และคุณต้องการสร้างโปรแกรมชื่อ "xyz" ต้องเกิดอะไรขึ้น?

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

ซีซี -g xyz.c -o xyz

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

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

คำสั่งสร้างไฟล์อ็อบเจ็กต์บน Unix มีลักษณะดังนี้:

ซีซี -g -c xyz.c -o xyz.o

"cc" คือคอมไพเลอร์ C บางครั้งใช้คอมไพเลอร์ C สำรอง ธรรมดามากคือ
เรียกว่า "จีซี" คอมไพเลอร์ C++ ทั่วไปคือคอมไพเลอร์ GNU ซึ่งมักจะเรียกว่า "g++" เสมือน
คอมไพเลอร์ C และ C++ ทั้งหมดบน Unix มีไวยากรณ์เดียวกันสำหรับส่วนที่เหลือของคำสั่ง (อย่างน้อย
สำหรับการดำเนินการพื้นฐาน) ดังนั้นความแตกต่างเพียงอย่างเดียวคือคำแรก

เราจะอธิบายว่าตัวเลือก "-g" ทำอะไรในภายหลัง

ตัวเลือก "-c" บอกให้คอมไพเลอร์ C สร้างไฟล์ ".o" เป็นเอาต์พุต (ถ้าคุณไม่
ระบุ "-c" จากนั้นดำเนินการขั้นตอนการรวบรวมที่สองโดยอัตโนมัติ)

ตัวเลือก "-o xyz.o" จะบอกคอมไพเลอร์ว่าชื่อไฟล์อ็อบเจ็กต์คืออะไร คุณสามารถ
ละเว้นสิ่งนี้ ตราบใดที่ชื่อของอ็อบเจ็กต์ไฟล์เหมือนกับชื่อของซอร์ส
ยกเว้นนามสกุล ".o"

โดยส่วนใหญ่ ลำดับของตัวเลือกและชื่อไฟล์ไม่สำคัญ หนึ่ง
ข้อยกเว้นที่สำคัญคือไฟล์เอาต์พุตต้องตามหลัง "-o" ทันที

การเชื่อมโยง
ขั้นตอนที่สองของการสร้างโปรแกรมเรียกว่า การเชื่อมโยง. ไม่สามารถเรียกใช้ไฟล์อ็อบเจ็กต์ได้
โดยตรง; เป็นรูปกลางที่ต้อง ที่เชื่อมโยง กับส่วนประกอบอื่นๆ เพื่อ
ผลิตโปรแกรม ส่วนประกอบอื่นๆ อาจรวมถึง:

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

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

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

คำสั่งเชื่อมโยงโปรแกรมมีลักษณะดังนี้:

ซีซี -g xyz.o -o xyz

อาจดูแปลก แต่เรามักจะเรียกใช้โปรแกรมเดียวกัน ("cc") เพื่อทำการลิงก์ อะไร
เกิดขึ้นภายใต้พื้นผิวคือโปรแกรม "cc" จะส่งผ่านการควบคุมไปยังa .ทันที
โปรแกรมอื่น (ตัวเชื่อมโยง บางครั้งเรียกว่าตัวโหลด หรือ "ld") หลังจากเพิ่มตัวเลข
ของข้อมูลที่ซับซ้อนไปยังบรรทัดคำสั่ง ตัวอย่างเช่น "cc" บอก "ld" โดยที่
ไลบรารีระบบมีคำจำกัดความของฟังก์ชันเช่น "printf" จนกระทั่งคุณ
เริ่มเขียนไลบรารีที่ใช้ร่วมกัน คุณไม่จำเป็นต้องจัดการกับ "ld" โดยตรง

หากคุณไม่ระบุ "-o xyz" ไฟล์เอาต์พุตจะเรียกว่า "a.out" ซึ่งดูเหมือน
สำหรับฉันจะเป็นแบบแผนที่ไร้ประโยชน์และสับสนอย่างสมบูรณ์ ดังนั้นให้ระบุ "-o" บน .เสมอ
ขั้นตอนการเชื่อมโยง

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

Why เธอ จำเป็นต้อง ไปยัง แยก ทำตามขั้นตอน
ทำไมไม่ลองใช้คำสั่งง่ายๆ ขั้นตอนเดียวแบบนี้:

ซีซี -g xyz.c -o xyz

แทนการรวบรวมสองขั้นตอนที่ซับซ้อนมากขึ้น

ซีซี -g -c xyz.c -o xyz.o
ซีซี -g xyz.o -o xyz

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

#คำสั่งขั้นตอนเดียว
ซีซี -g xyz.c abc.c -o xyz

or

#คำสั่งสองขั้นตอน
ซีซี -g -c xyz.c -o xyz.o
ซีซี -g -c abc.c -o abc.o
ซีซี -g xyz.o abc.o -o xyz

แน่นอนว่าวิธีแรกจะถูกแปลงเป็นการภายในเป็นวิธีที่สอง แปลว่า
ที่ทั้ง "xyz.c" และ "abc.c" จะถูกคอมไพล์ใหม่ทุกครั้งที่รันคำสั่ง แต่ถ้าคุณ
เปลี่ยนเฉพาะ "xyz.c" เท่านั้น ไม่จำเป็นต้องคอมไพล์ "abc.c" ใหม่ ดังนั้นบรรทัดที่สองของสอง-
ไม่จำเป็นต้องทำคำสั่งขั้นตอน สิ่งนี้สามารถสร้างความแตกต่างอย่างมากในการรวบรวม
เวลา โดยเฉพาะอย่างยิ่งถ้าคุณมีโมดูลจำนวนมาก ด้วยเหตุนี้ makefiles เกือบทั้งหมดจึงเก็บ
สองขั้นตอนการรวบรวมแยกจากกัน

นั่นเป็นพื้นฐานที่ค่อนข้างมาก แต่มีรายละเอียดเล็กๆ น้อยๆ อีกเล็กน้อยที่คุณควรทำ
รู้เกี่ยวกับ.

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

ด้วยความสามารถในการทำกำไรมหาศาลเช่นนี้ ทำไมคุณถึงไม่อยากเพิ่มประสิทธิภาพล่ะ? ที่สุด
คำตอบที่สำคัญคือการเพิ่มประสิทธิภาพทำให้การใช้ดีบักเกอร์ยากขึ้นมาก
(บางครั้งก็เป็นไปไม่ได้) (หากคุณไม่รู้อะไรเกี่ยวกับตัวดีบั๊ก ก็ถึงเวลาเรียนรู้
ครึ่งชั่วโมงหรือชั่วโมงที่คุณใช้ในการเรียนรู้พื้นฐานจะได้รับการตอบแทนหลายครั้ง
ในเวลาที่คุณจะประหยัดได้ในภายหลังเมื่อทำการดีบั๊ก ฉันขอแนะนำให้เริ่มต้นด้วยดีบักเกอร์ GUI
เช่น "kdbg", "ddd" หรือ "gdb" ที่เรียกใช้จากภายใน emacs (ดูหน้าข้อมูลบน gdb สำหรับ
คำแนะนำเกี่ยวกับวิธีการทำเช่นนี้)) การเพิ่มประสิทธิภาพเรียงลำดับใหม่และรวมคำสั่งลบ
ตัวแปรชั่วคราวที่ไม่จำเป็น และโดยทั่วไปจะจัดเรียงโค้ดของคุณใหม่เพื่อให้เป็น
ยากที่จะติดตามภายในดีบักเกอร์ ขั้นตอนปกติคือการเขียนโค้ดของคุณ คอมไพล์มัน
โดยไม่ต้องปรับให้เหมาะสม แก้จุดบกพร่อง แล้วเปิดการปรับให้เหมาะสม

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

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

gcc -O6 -malign-double -c xyz.c -o xyz.o

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

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

หากคุณไม่ระบุ "-g" หรือ "-O" ในคำสั่งการคอมไพล์ ผลลัพธ์ที่ได้คือวัตถุ
ไฟล์ไม่เหมาะสำหรับการดีบั๊กหรือทำงานเร็ว ด้วยเหตุผลบางอย่างนี่คือ
ค่าเริ่มต้น. ดังนั้นให้ระบุ "-g" หรือ "-O" เสมอ

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

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

gcc -g -ผนัง -c xyz.c -o xyz.o

(บางครั้งฉันยังเพิ่ม "-Wno-uninitialized" หลัง "-Wall" เนื่องจากคำเตือนคือ
มักจะผิดที่ครอบตัดเมื่อเพิ่มประสิทธิภาพ)

คำเตือนเหล่านี้ช่วยฉันประหยัดเวลาในการดีบั๊กได้หลายชั่วโมง

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

สมมติว่า คุณกำลังเขียนแอปพลิเคชันที่ใช้ไลบรารี Qt คุณได้
ติดตั้งสำเนาในเครื่องของไลบรารี Qt ใน /home/users/joe/qtซึ่งหมายความว่า
รวมไฟล์ถูกเก็บไว้ในไดเร็กทอรี /home/users/joe/qt/include. ในรหัสของคุณ คุณ
ต้องการที่จะสามารถทำสิ่งนี้:

#รวม

แทน

#include "/home/users/joe/qt/include/qwidget.h"

คุณสามารถบอกให้คอมไพเลอร์ค้นหาการรวมไฟล์ในไดเร็กทอรีอื่นโดยใช้คำสั่ง
ตัวเลือกการรวบรวม "-I":

g++ -I/home/users/joe/qt/include -g -c mywidget.cpp -o mywidget.o

โดยปกติแล้วจะไม่มีช่องว่างระหว่าง "-I" กับชื่อไดเร็กทอรี

เมื่อคอมไพเลอร์ C++ ค้นหาไฟล์ qwidget.h, มันจะดูใน
/home/users/joe/qt/include ก่อนที่จะดูในระบบรวมถึงไดเร็กทอรี คุณสามารถ
ระบุตัวเลือก "-I" ได้มากเท่าที่คุณต้องการ

การใช้ ห้องสมุด
คุณมักจะต้องบอกตัวเชื่อมโยงให้เชื่อมโยงกับไลบรารีภายนอกที่เฉพาะเจาะจง หากคุณ
กำลังเรียกใช้ฟังก์ชันใด ๆ ที่ไม่ได้เป็นส่วนหนึ่งของไลบรารี C มาตรฐาน ตัว "-l" (ตัวพิมพ์เล็ก
L) ตัวเลือกบอกว่าจะเชื่อมโยงกับห้องสมุดเฉพาะ:

ซีซี -g xyz.o -o xyz -lm

"-lm" บอกว่าจะเชื่อมโยงกับไลบรารีคณิตศาสตร์ของระบบ ซึ่งคุณจะต้องใช้หากคุณกำลังใช้
ฟังก์ชั่นเช่น "sqrt"

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

บางครั้งไลบรารีที่คุณต้องการจะไม่ถูกเก็บไว้ในตำแหน่งเริ่มต้นสำหรับ system
ห้องสมุด "-labc" ค้นหาไฟล์ชื่อ libabc.a or libab.so or libab.sa ใน
ไดเร็กทอรีไลบรารีระบบ (/ usr / lib และมักจะมีที่อื่นด้วย ขึ้นอยู่กับว่า
Unix ที่คุณใช้งานอยู่) ตัวเลือก "-L" ระบุไดเร็กทอรีเพิ่มเติมเพื่อค้นหา
สำหรับห้องสมุด หากต้องการนำตัวอย่างข้างต้นอีกครั้ง สมมติว่าคุณได้ติดตั้งไลบรารี Qt
in /home/users/joe/qtซึ่งหมายความว่าไฟล์ไลบรารีอยู่ใน /home/users/joe/qt/lib.
ขั้นตอนการเชื่อมโยงสำหรับโปรแกรมของคุณอาจมีลักษณะดังนี้:

g ++ -g test_mywidget.o mywidget.o -o test_mywidget -L/home/users/joe/qt/lib -lqt

(ในบางระบบ หากคุณเชื่อมโยงใน Qt คุณจะต้องเพิ่มไลบรารีอื่นด้วย (เช่น
"-L/usr/X11R6/lib -lX11 -lXext") สิ่งที่คุณต้องทำจะขึ้นอยู่กับระบบของคุณ)

โปรดทราบว่าไม่มีช่องว่างระหว่าง "-L" และชื่อไดเร็กทอรี ตัวเลือก "-L" มักจะ
ไปก่อนตัวเลือก "-l" ใด ๆ ที่มันควรจะส่งผลกระทบ

คุณรู้ได้อย่างไรว่าห้องสมุดใดที่คุณต้องการ? โดยทั่วไปนี่เป็นคำถามที่ยากและแตกต่างกันไป
ขึ้นอยู่กับประเภทของ Unix ที่คุณใช้ เอกสารประกอบสำหรับฟังก์ชันหรือ
ชั้นเรียนที่คุณใช้ควรบอกว่าห้องสมุดใดที่คุณต้องการเชื่อมโยง หากคุณกำลังใช้
ฟังก์ชั่นหรือคลาสจากแพ็คเกจภายนอก มักจะมีไลบรารี่ที่คุณต้องเชื่อมโยง
กับ; ไลบรารีมักจะเป็นไฟล์ชื่อ "libabc.a" หรือ "libabc.so" หรือ "libabc.sa"
หากคุณต้องการเพิ่มตัวเลือก "-labc"

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

ซีซี -g -L/usr/X11R6/lib -c xyz.c -o xyz.o
cc -g -I/ที่ไหนสักแห่ง/รวม xyz.o -o xyz

ตัวเลือกที่ไม่เกี่ยวข้องจะถูกละเว้น คำสั่งข้างต้นนั้นเทียบเท่ากับสิ่งนี้:

ซีซี -g -c xyz.c -o xyz.o
ซีซี -g xyz.o -o xyz

ใช้ makepp_tutorial_compilation ออนไลน์โดยใช้บริการ onworks.net