‫สวัสดีและยินดีต้อนรับ.
‫ในการบรรยายนี้ เราจะทำความเข้าใจขั้นตอนหลักที่เกี่ยวข้องกับการคอมไพล์ไฟล์ C++ ใน
‫Unreal
‫มาดูวิธีการทำงานกันเลย
‫ดังนั้น อีกไม่นานจะถึงเวลาที่เราจะเริ่มต้นใช้โค้ดจากภายนอก จากไฟล์อื่น และเราต้องเรียนรู้วิธีการทำงานของโค้ดใน
‫C++
‫ในการทำเช่นนั้น เราต้องใช้ทางเบี่ยงเล็กน้อยและทำความเข้าใจในรายละเอียดเพิ่มเติมว่าเกิดอะไรขึ้นเมื่อเราคอมไพล์โค้ด
‫C++ เป็นไบนารี
‫นี่คือขั้นตอนการคอมไพล์ที่ใช้
‫เราเริ่มต้นด้วยโค้ดของคุณ ไฟล์ C++ ไฟล์ส่วนหัว ทั้งหมดในไฟล์ข้อความต่างๆ
‫สิ่งเหล่านี้ถูกป้อนเข้าไปในเครื่องมือที่เรียกว่า Unreal Header Tool
‫ตอนนี้ เครื่องมือนี้มีหน้าที่รับส่วนไวยากรณ์ที่ไม่จริงทั้งหมดและใช้เพื่อสร้างโค้ด
‫C++ เพิ่มเติม
‫ลองมาดูตัวอย่างที่เรามีไวยากรณ์เฉพาะที่ไม่จริงนี้ คลาสใหม่นี้เป็นตัวพิมพ์ใหญ่ที่มีรูปแบบเฉพาะที่ไม่จริง
‫เช่นเดียวกับ Crypt Reader API ที่นี่และเนื้อหาที่สร้างขึ้นที่นั่น
‫และโดยพื้นฐานแล้ว สิ่งที่เกิดขึ้นที่นี่คือเครื่องมือส่วนหัวที่ไม่จริง จะเห็นส่วนต่างๆ ของไวยากรณ์เหล่านี้ในโค้ดของคุณและไปได้เลย
‫ฉันต้องทำงานของฉัน
‫ฉันต้องเข้าไปข้างใน ฉันต้องเพิ่มอะไรหลายๆ อย่าง
‫มันจะแทนที่เนื้อหาที่คุณสร้างขึ้นด้วยรหัสจำนวนมากที่ทำให้ชีวิตของเราง่ายขึ้นเมื่อใช้
‫Unreal
‫นอกจากนี้ยังทำสิ่งต่างๆ เช่น คุณสมบัติ U และฟังก์ชันใหม่
‫มันเพิ่มทุกสิ่งที่จำเป็นเพื่อให้สามารถสื่อสารกับโลกพิมพ์เขียว
‫นั่นคือขั้นตอนแรก
‫มันแปลงสิ่งที่ไม่จริงทั้งหมดเป็น C ++ จริง
‫เมื่อเราได้ C++ จริงแล้ว เราก็สามารถป้อนลงในกระบวนการคอมไพล์ C++ มาตรฐานได้ ซึ่งใช้เวลาสามขั้นตอน
‫อย่างแรกคือจัดการกับขั้นตอนก่อนการประมวลผลเพื่อให้สามารถสัมผัสไวยากรณ์ C ++ ใดก็ได้และเกี่ยวข้องกับบรรทัดที่ขึ้นต้นด้วยแฮชเท่านั้น
‫ดังนั้นเราจึงมีคำสั่งก่อนการประมวลผลบางส่วนเหล่านี้
‫สิ่งเหล่านี้ได้รับการจัดการโดยตัวประมวลผลล่วงหน้า
‫ขั้นตอนต่อไปคือสิ่งที่เราเรียกว่าคอมไพเลอร์
‫มันใช้รหัสและแปลงเป็นไบนารีที่ปฏิบัติการได้ แต่มันยังไม่สมบูรณ์ตามขั้นตอนเพราะมันทำกับ
‫C++ แต่ละตัวเท่านั้น สิ่งที่เรียกว่าหน่วยการแปล โดยทั่วไปคือไฟล์ C++
‫ดังนั้นจึงใช้ไฟล์ C++ และแปลเป็นไบนารีทีละไฟล์ แต่ละไฟล์ C++
‫จากนั้นขั้นตอนที่สามคือตัวเชื่อมโยง ซึ่งนำสิ่งเหล่านั้นมารวมกันและส่งออกไฟล์ปฏิบัติการที่เราสามารถเรียกใช้โปรแกรมเรียกทำงานเดียวได้จริง
‫ลองมาดูขั้นตอนการคอมไพล์มาตรฐานเหล่านี้ในรายละเอียดเพิ่มเติมเล็กน้อยด้วยไฟล์ตัวอย่าง
‫ลองนึกภาพว่าเรามีเกม
‫CP และเป็นเกมที่ง่ายมาก ๆ เพราะทั้งหมดที่ทำคือเพิ่มหนึ่งและหนึ่งเข้าด้วยกัน แต่การเพิ่มหนึ่งและหนึ่งเข้าด้วยกันคือต้องใช้ฟังก์ชันที่ประกาศไว้ในไฟล์อื่นในวิชาคณิตศาสตร์
‫H ดังนั้นคณิตศาสตร์จึงประกาศ
‫AD แต่จริง ๆ แล้วมันไม่ได้กำหนดสิ่งที่มันทำ
‫นั่นก็จบไปแล้วในวิชาคณิตศาสตร์
‫CP และคุณจะเห็นว่ามันเป็นการใช้งานที่ง่ายมากจริงๆ
‫เกิดอะไรขึ้นที่ขั้นตอนพรีโปรเซสเซอร์?
‫อย่างที่ฉันบอกไป มันเกี่ยวข้องกับคำสั่งของตัวประมวลผลล่วงหน้า ซึ่งเป็นสิ่งที่ขึ้นต้นด้วยแฮช
‫ดังนั้นแฮชจึงรวมเลขคณิตไว้ด้วย ซึ่งโดยพื้นฐานแล้วหมายถึงแค่คัดลอกทุกอย่างในวิชาคณิตศาสตร์มาไว้ที่นี่
‫ดังนั้นสิ่งที่ทำคือใช้สองไฟล์นี้และรวมเข้าด้วยกันเพื่อสร้างไฟล์เอาท์พุตใหม่ที่เรียกว่า
‫Game I โดยพื้นฐานแล้วเกมรวมถึงและคุณจะเห็นว่าได้รวมคำจำกัดความจาก Master H และแทนที่คำสั่ง
‫hash preprocessor
‫ดังนั้นตอนนี้ Game II จึงมีคำจำกัดความสำหรับการดำเนินการ ADD จากนั้นเราเรียกใช้ตัวประมวลผลล่วงหน้าใน DHCP ทางคณิตศาสตร์
‫แต่เนื่องจากไม่มีคำสั่งของตัวประมวลผลล่วงหน้า โดยพื้นฐานแล้วจึงไม่มีอะไรเปลี่ยนแปลงที่นั่น
‫ขั้นตอนต่อไปคือการคอมไพล์น่าจะเป็นขั้นตอนที่สำคัญและซับซ้อนที่สุด
‫เพราะสิ่งที่ทำคือใช้ C++ นั้นในแต่ละไฟล์และแปลงเป็นไบนารี่ แต่มันไม่ใช่ไบนารีที่สมบูรณ์เพราะเช่น
‫เกมของฉันไม่จริง รู้วิธีใช้งาน AD เพียงแค่รู้รูปร่างของฟังก์ชันเพิ่มนั้น
‫ดังนั้นจำเป็นต้องกรอกข้อมูลในภายหลังและตัวเชื่อมโยงจะกรอกข้อมูล
‫ดังนั้นตัวเชื่อมโยงจะนำไบนารีที่สร้างขึ้นสำหรับไฟล์ obj ของเกมและไบนารีที่สร้างขึ้นสำหรับไฟล์หลักและนำมารวมกันเพื่อสร้างเกม
‫XY ซึ่งรวมไบนารีสำหรับทั้งคู่ และสุดท้ายเป็นไฟล์เรียกทำงานที่สมบูรณ์ซึ่งเราสามารถเรียกใช้ได้จริง เพราะมันมีคำจำกัดความสำหรับทุกสิ่งที่ต้องการ
‫ทำไมเราถึงมีกระบวนการที่ซับซ้อนเช่นนี้?
‫แนวคิดในที่นี้คือ มันทำให้เวลาในการรวบรวมของเราเร็วขึ้น เพราะถ้าฉันทำการเปลี่ยนแปลงเพียงอย่างเดียว
‫เพื่อเล่นเกม DHCP
‫ฉันไม่จำเป็นต้องรันกระบวนการคอมไพล์ทั้งหมด
‫ทั้งหมดที่ฉันต้องทำคือเรียกใช้บิตที่เกี่ยวข้องกับเกม DHCP ดังนั้นฉันจะเรียกใช้ตัวประมวลผลล่วงหน้าบน
‫CP เท่านั้น จากนั้นฉันจะเรียกใช้คอมไพเลอร์ในเกมกับ I เท่านั้น จากนั้นฉันจะนำไฟล์คณิตศาสตร์ obj กลับมาใช้ใหม่ได้
‫ฉันไม่จำเป็นต้องคอมไพล์ใหม่เพราะไม่มีอะไรเปลี่ยนแปลงในนั้น
‫ในทำนองเดียวกัน ถ้าฉันเปลี่ยนแค่ dot CP ทางคณิตศาสตร์ ฉันจะไม่ต้องคอมไพล์ไฟล์ obj ของเกมอีกครั้ง ซึ่งเป็นสาเหตุที่ทำให้กระบวนการนี้มีประสิทธิภาพมากขึ้นและทำไมเราถึงทำอย่างนั้นตั้งแต่แรก
‫เลยอยากให้เราทำการทดลองเล็กๆ น้อยๆ แล้วลองคิดดูว่าเหตุใดเราจึงรวมการย้าย H เข้าและย้ายไฟล์
‫CP
‫อะไรคือสาเหตุของมัน?
‫ทำไมเราไม่สามารถรวบรวมไฟล์ C ++ โดยไม่ต้องย้าย?
‫H การทดลองที่เราจะทำคือเราจะแสดงความคิดเห็นเกี่ยวกับบรรทัดรวมแฮช
‫ดังนั้นการใช้เครื่องหมายทับสองครั้งเพื่อแสดงความคิดเห็นที่ด้านหน้าของบรรทัดนั้น ซึ่งโดยพื้นฐานแล้วจะทำให้ตัวประมวลผลล่วงหน้าหลุดออกมา
‫แทนที่จะให้ตัวประมวลผลล่วงหน้าแทนที่ด้วยเนื้อหาของไฟล์
‫จากนั้นเราจะคอมไพล์ใหม่ และฉันต้องการให้คุณดูข้อความแสดงข้อผิดพลาดที่ออกมาและดูว่ามีข้อความว่าอย่างไร
‫เพื่อดูว่าคุณสามารถลองและทำความเข้าใจว่าเรากำลังรวมการเคลื่อนไหวนี้ไว้เพื่ออะไร
‫หยุดวิดีโอชั่วคราวและไปกันเลย
‫ตกลง.
‫ยินดีต้อนรับกลับ.
‫ลองใส่เครื่องหมายทับสองครั้งที่จุดเริ่มต้นของบรรทัดนี้ ซึ่งโดยทั่วไปจะทำให้เป็นโมฆะและเป็นโมฆะ
‫จากนั้นเราจะทำการควบคุม alt f 11 และเราจะดูที่ผลลัพธ์ของ live coding
‫ดูสิ เรามีข้อผิดพลาดเกิดขึ้นตั้งแต่เนิ่นๆ
‫และสิ่งที่กำลังพูดก็คือคุณเป็นผู้เสนอญัตติไม่ใช่คลาสหรือเนมสเปซ และยังมีสิ่งอื่น ๆ อยู่ด้านล่าง
‫มันบอกว่าองค์ประกอบเทคโนโลยีหลักไม่ได้รับการประกาศว่า super ไม่ใช่คลาสหรือเจ้าของเนมสเปซเป็นตัวระบุที่ไม่รู้จัก
‫และโดยพื้นฐานแล้ว ที่พูดนี้คือคุณได้พูดถึงคุณที่นี่ แต่คุณไม่ได้นิยามมันไว้ที่ไหน
‫คุณไม่ได้ประกาศมันที่ไหนเลย
‫ฉันก็เลยไม่รู้
‫คอมไพเลอร์ C++ บอกว่า ฉันไม่รู้ว่านี่คืออะไร
‫นั่นคือเหตุผลที่เราเป็นแฮช รวมถึงผู้เสนอญัตติ H เนื่องจากผู้เสนอญัตติ H ประกาศคลาส
‫มันบอกว่าผู้เสนอญัตติ U เป็นคลาสและเกิดขึ้นจากคุณทำหน้าที่ส่วนประกอบและมีวิธีเหล่านี้ ฯลฯ
‫เป็นการประกาศว่าการเป็นคลาสนั้นหมายความว่าอย่างไร
‫ดังนั้นหากไม่มีการประกาศนั้น คอมไพเลอร์ C++ ก็ไม่สามารถดำเนินการต่อได้
‫และนั่นเป็นเหตุผลที่เราต้องรวมไฟล์ส่วนหัวนั้นไว้ด้วย
‫สิ่งที่ดี
‫หวังว่าตอนนี้คุณจะเข้าใจกระบวนการที่เกี่ยวข้องกับการรวบรวม C++ และโดยเฉพาะอย่างยิ่งการรวบรวม
‫C++ ใน Unreal ดีขึ้นเล็กน้อย
‫แล้วพบกันใหม่ในบทเรียนหน้าครับ