เวลาของการคอมไพล์เทียบกับเวลา

ความแตกต่างระหว่างเวลาทำงานและเวลารวบรวมคืออะไร?

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

1. โปรแกรมไม่เปลี่ยนแปลงอะไรที่ตอบสนอง?
2. มีอะไรผิดปกติในระยะนี้
3. หากเฟสประสบความสำเร็จอะไรคือ postconditions (เรารู้อะไร)
4. อินพุตและเอาต์พุตคืออะไรถ้ามี?

รวบรวมเวลา

1. โปรแกรมไม่จำเป็นต้องตอบสนองค่าคงที่ใด ๆ ความจริงแล้วมันไม่จำเป็นต้องเป็นโปรแกรมที่มีรูปแบบที่ดีเลย คุณสามารถป้อน HTML นี้เพื่อคอมไพเลอร์และดูมัน barf ...
2. สิ่งที่ผิดพลาดในเวลารวบรวม:
   • ข้อผิดพลาดทางไวยากรณ์
   • พิมพ์ข้อผิดพลาด
   • คอมไพเลอร์ล่ม (หายาก)
3. หากคอมไพเลอร์ประสบความสำเร็จเรารู้อะไรบ้าง
   • โปรแกรมได้รับการพัฒนาขึ้นมาอย่างดี --- เป็นโปรแกรมที่มีความหมายในทุกภาษา
   • เป็นไปได้ที่จะเริ่มต้นใช้งานโปรแกรม (โปรแกรมอาจล้มเหลวทันที แต่อย่างน้อยเราก็ลองได้)
4. อินพุตและเอาต์พุตคืออะไร
   • อินพุตคือโปรแกรมที่กำลังรวบรวมรวมถึงไฟล์ส่วนหัวอินเทอร์เฟซไลบรารีหรือ voodoo อื่น ๆ ที่จำเป็นต้องนำเข้าเพื่อรวบรวม
   • ผลลัพธ์คือหวังว่าจะประกอบรหัสหรือรหัสวัตถุ relocatable หรือแม้กระทั่งโปรแกรมปฏิบัติการ หรือถ้ามีบางอย่างผิดปกติผลลัพธ์ก็คือข้อความแสดงข้อผิดพลาด

ใช้เวลา

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

2. สิ่งที่สามารถผิดพลาดได้คือข้อผิดพลาดรันไทม์ :

   • การหารด้วยศูนย์
   • การอ้างอิงตัวชี้ null
   • หน่วยความจำไม่เพียงพอ

   นอกจากนี้ยังอาจมีข้อผิดพลาดที่ตรวจพบโดยตัวโปรแกรมเอง:

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

ฉันคิดว่ามันในแง่ของข้อผิดพลาดและเมื่อพวกเขาสามารถถูกจับได้

รวบรวมเวลา:

string my_value = Console.ReadLine();
int i = my_value;

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

เวลาทำงาน:

string my_value = Console.ReadLine();
int i = int.Parse(my_value);

ที่นี่ผลลัพธ์ขึ้นอยู่กับว่าสายใดถูกส่งกลับโดย ReadLine () ค่าบางค่าสามารถแยกวิเคราะห์เป็น int ส่วนอื่นไม่สามารถทำได้ สิ่งนี้สามารถกำหนดได้ในเวลาทำงานเท่านั้น

Compile-time:ช่วงเวลาที่คุณเป็นผู้พัฒนากำลังรวบรวมรหัสของคุณ

Run-time:ช่วงเวลาที่ผู้ใช้รันซอฟต์แวร์ของคุณ

คุณต้องการคำจำกัดความที่ชัดเจนกว่านี้ไหม?

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

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

int i = "string"; --> error at compile-time

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

Hashtable ht = new Hashtable();
ht.Add("key", "string");
// the compiler does not know what is stored in the hashtable
// under the key "key"
int i = (int)ht["key"];  // --> exception at run-time

การแปลซอร์สโค้ดเป็นสิ่งที่เกิดขึ้นบนหน้าจอ [ดิสก์ | เครือข่าย] สามารถเกิดขึ้นได้สองวิธี (คร่าวๆ); เรียกพวกเขารวบรวมและตีความ

ในโปรแกรมที่คอมไพล์ (ตัวอย่างคือ c และ fortran):

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

สิ่งที่เกิดขึ้นในขั้นตอนแรกจะกล่าวว่าเกิดขึ้นที่ "เวลารวบรวม" สิ่งที่เกิดขึ้นในขั้นตอนที่สองจะกล่าวว่าเกิดขึ้นที่ "เวลาทำงาน"

ในโปรแกรมที่แปล (ตัวอย่าง MicroSoft พื้นฐาน (บน dos) และ python (ฉันคิดว่า):

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

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

Java เป็นประเภทไฮบริดที่โค้ดจะถูกคอมไพล์ไปเป็น bytecode ซึ่งจะทำงานบนเครื่องเสมือนซึ่งมักจะเป็นล่ามสำหรับ bytecode

นอกจากนี้ยังมีตัวพิมพ์กลางซึ่งโปรแกรมถูกคอมไพล์ไปเป็น bytecode และรันทันที (เหมือน awk หรือ perl)

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

เช่น.

พับอย่างต่อเนื่อง:

ถ้าฉันเขียน:

int i = 2;
i += MY_CONSTANT;

คอมไพเลอร์สามารถทำการคำนวณนี้ในเวลาคอมไพล์เพราะรู้ว่า 2 คืออะไรและ MY_CONSTANT คืออะไร เช่นนี้จะช่วยตัวเองจากการคำนวณทุกการประมวลผลเดียว

อืมโอเครันไทม์ใช้เพื่ออธิบายสิ่งที่เกิดขึ้นเมื่อโปรแกรมทำงาน

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

เวลารวบรวม:

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

เริ่มเวลา:

มากหรือน้อยตรงข้ามแน่นอน ค่าใช้จ่ายน้อยเมื่อคุณสร้างค่าใช้จ่ายเพิ่มเติมเมื่อโปรแกรมทำงาน

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

ความสัมพันธ์กัน

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

การติดตามคำถามที่คล้ายกันก่อนหน้านี้ข้อแตกต่างระหว่างข้อผิดพลาดรันไทม์และข้อผิดพลาดคอมไพเลอร์คืออะไร

การคอมไพล์ / เวลาคอมไพล์ / ข้อผิดพลาดทางไวยากรณ์ / ความหมาย: ข้อผิดพลาดในการรวบรวมหรือการคอมไพล์เกิดจากข้อผิดพลาดในการพิมพ์หากเราไม่ปฏิบัติตามไวยากรณ์และซีแมนทิกส์ที่เหมาะสมของภาษาการเขียนโปรแกรมใด ๆ พวกเขาจะไม่ยอมให้โปรแกรมของคุณรันบรรทัดเดียวจนกว่าคุณจะลบข้อผิดพลาดทางไวยากรณ์ทั้งหมดหรือจนกว่าคุณจะทำการดีบักข้อผิดพลาดของเวลาการคอมไพล์
ตัวอย่าง: หายไปอัฒภาคใน C หรือ mistyping เป็นintInt

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

อ่านเพิ่มเติมเกี่ยวกับข้อผิดพลาดในการเขียนโปรแกรมทั้งหมดที่นี่

ในฐานะที่เป็นส่วนเสริมของคำตอบอื่น ๆ นี่คือวิธีที่ฉันจะอธิบายให้คนธรรมดา:

ซอร์สโค้ดของคุณเป็นเหมือนพิมพ์เขียวของเรือ มันกำหนดว่าเรือควรทำอย่างไร

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

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

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

ในความแตกต่างเพียงคำ b / w เวลารวบรวมและเวลาเรียกใช้

เวลารวบรวม: นักพัฒนาเขียนโปรแกรมในรูปแบบ. java & แปลงเป็น Bytecode ซึ่งเป็นไฟล์คลาสในระหว่างการรวบรวมนี้ข้อผิดพลาดใด ๆ ที่เกิดขึ้นสามารถกำหนดเป็นข้อผิดพลาดเวลารวบรวม

เวลาทำงาน: แอปพลิเคชั่นไฟล์ที่สร้างขึ้นนั้นใช้สำหรับการทำงานเพิ่มเติม & ตรรกะปรากฎว่าผิดและมีข้อผิดพลาดซึ่งเป็นข้อผิดพลาดในเวลาทำงาน

นี่คือคำพูดจาก Daniel Liang ผู้เขียน 'Introduction to JAVA programming' ในหัวข้อการรวบรวม:

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

... เขายังคง ...

"คอมไพเลอร์แปลซอร์สโค้ดทั้งหมดเป็นไฟล์รหัสเครื่องและไฟล์รหัสเครื่องจะถูกเรียกใช้งาน"

เมื่อเราเจาะโค้ดระดับสูง / มนุษย์อ่านได้นี่คือตอนแรกไร้ประโยชน์! มันจะต้องแปลเป็นลำดับของ 'เหตุการณ์ทางอิเล็กทรอนิกส์' ใน CPU ตัวจิ๋วของคุณ! ขั้นตอนแรกในการรวบรวมคือ

ใส่เพียง: ข้อผิดพลาดเวลารวบรวมเกิดขึ้นในช่วงนี้ในขณะที่ข้อผิดพลาดรันไทม์เกิดขึ้นในภายหลัง

เตือนความจำ: เพียงเพราะโปรแกรมที่คอมไพล์โดยไม่มีข้อผิดพลาดไม่ได้หมายความว่ามันจะทำงานโดยไม่มีข้อผิดพลาด

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

ตัวอย่างข้อผิดพลาดการคอมไพล์เวลา:

ข้อผิดพลาดทางไวยากรณ์ - รหัสของคุณสามารถรวบรวมเป็นคำแนะนำในระดับเครื่องได้อย่างไรหากรหัสเหล่านั้นไม่ชัดเจน? รหัสของคุณต้องสอดคล้องกับกฎการใช้ภาษา 100% ไม่เช่นนั้นจะไม่สามารถรวบรวมเป็นรหัสเครื่องที่ใช้งานได้

ตัวอย่างข้อผิดพลาดรันไทม์:

หน่วยความจำไม่เพียงพอ - การเรียกฟังก์ชั่นวนซ้ำอาจนำไปสู่การโอเวอร์โฟลว์แบบสแต็กเนื่องจากตัวแปรในระดับหนึ่ง! คอมไพเลอร์คาดหวังได้อย่างไร? มันไม่สามารถ

และนั่นคือข้อแตกต่างระหว่างข้อผิดพลาดในการคอมไพล์และข้อผิดพลาดรันไทม์

เวลารันหมายถึงบางสิ่งบางอย่างเกิดขึ้นเมื่อคุณเรียกใช้โปรแกรม

เวลารวบรวมหมายถึงบางสิ่งที่เกิดขึ้นเมื่อคุณรวบรวมโปรแกรม

เวลารวบรวม:

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

มากหรือน้อยตรงข้ามแน่นอน ค่าใช้จ่ายน้อยเมื่อคุณสร้างค่าใช้จ่ายเพิ่มเติมเมื่อโปรแกรมทำงาน

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

เวลาในการคอมไพล์: เวลาที่ใช้ในการแปลงซอร์สโค้ดเป็นรหัสเครื่องเพื่อให้สามารถเรียกใช้งานได้จะเรียกว่าเวลารวบรวม

เวลาทำงาน: เมื่อแอปพลิเคชันทำงานจะเรียกว่าเวลาทำงาน

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

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

นี่คือส่วนขยายของคำตอบสำหรับคำถาม "ความแตกต่างระหว่างเวลาทำงานและเวลาคอมไพล์หรือไม่" - ความแตกต่างของค่าโสหุ้ยที่เกี่ยวข้องกับเวลาทำงานและเวลารวบรวม?

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

แหล่งที่ดีสำหรับการอ่านเพิ่มเติมที่นี่ :

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

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

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

วิธีจัดการแบบไดนามิกนั้นจะขึ้นอยู่กับภาษาคอมไพเลอร์ระบบปฏิบัติการโค้ดของคุณ ฯลฯ

ในบันทึกย่อนั้นจริง ๆ มันจะขึ้นอยู่กับบริบทที่คุณใช้เวลาทำงานเทียบกับเวลารวบรวม

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

Joseph Kulandai

ความแตกต่างที่สำคัญระหว่างเวลาทำงานและเวลาคอมไพล์คือ:

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

int a = 1 int b = a/0;

บรรทัดแรกที่นี่ไม่มีเซมิโคลอนท้าย -> ข้อผิดพลาดเวลาคอมไพล์หลังจากรันโปรแกรมในขณะที่ดำเนินการปฏิบัติการขผลลัพธ์ที่ได้คืออนันต์ ---> ข้อผิดพลาดรันไทม์

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

นี่เป็นคำตอบที่ง่ายมาก:

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

โปรแกรมที่คอมไพล์สามารถเปิดและรันโดยผู้ใช้ เมื่อแอปพลิเคชันทำงานจะเรียกว่ารันไทม์

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

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

การอ้างอิง

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

นอกเหนือจากที่กล่าวไว้ข้างต้นฉันต้องการเพิ่มบางครั้งรูปภาพที่มีมูลค่า 1,000 คำ:

1. ลำดับของทั้งสองนี้ก่อนคือเวลารวบรวมจากนั้นคุณเรียกใช้โปรแกรมที่คอมไพล์สามารถเปิดและรันโดยผู้ใช้ เมื่อแอปพลิเคชันทำงานจะเรียกว่ารันไทม์: รวบรวมเวลาแล้วรันไทม์ 1 ;

CLR_diag เวลาคอมไพล์แล้ว runtime2

 from Wiki  

https://en.wikipedia.org/wiki/Run_time https://en.wikipedia.org/wiki/Run_time_(program_lifecycle_phase)

เวลารันไทม์รันไทม์หรือรันไทม์อาจอ้างถึง:

คอมพิวเตอร์

Run time (เฟสวัฏจักรชีวิตของโปรแกรม)ช่วงเวลาที่โปรแกรมคอมพิวเตอร์กำลังทำงาน

รันไทม์ไลบรารี่เป็นไลบรารี่ของโปรแกรมที่ออกแบบมาเพื่อใช้งานฟังก์ชั่นที่สร้างขึ้นในภาษาการเขียนโปรแกรม

ระบบรันไทม์ซอฟต์แวร์ที่ออกแบบมาเพื่อรองรับการทำงานของโปรแกรมคอมพิวเตอร์

การประมวลผลซอฟต์แวร์กระบวนการของการปฏิบัติตามคำแนะนำทีละหนึ่งในช่วงเวลาทำงาน

รายการคอมไพเลอร์ https://en.wikipedia.org/wiki/List_of_compilers

• ค้นหาใน google และเปรียบเทียบข้อผิดพลาดรันไทม์เทียบกับข้อผิดพลาดในการคอมไพล์:

;

3. ในความคิดของฉันเป็นสิ่งสำคัญที่ต้องรู้: 3.1 ความแตกต่างระหว่าง build vs คอมไพล์และ Build Lifecycle https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

3.2 ข้อแตกต่างระหว่าง 3 สิ่งนี้: คอมไพล์ vs บิวด์ vs รันไทม์

https://www.quora.com/What-is-the-difference-between-build-run-and-compile เฟอร์นันโดปาโดอันนักพัฒนาที่ค่อนข้างอยากรู้อยากเห็นสำหรับการออกแบบภาษาตอบ 23 ก.พ. ฉันจะย้อนกลับไปในความสัมพันธ์ เพื่อคำตอบอื่น ๆ :

การรันกำลังทำให้ไบนารี่ไบนารี (หรือสคริปต์สำหรับภาษาที่ตีความ) บางส่วนทำงานได้ดี ... ถูกเรียกใช้เป็นกระบวนการใหม่บนคอมพิวเตอร์ การคอมไพล์เป็นกระบวนการของการแยกวิเคราะห์โปรแกรมที่เขียนด้วยภาษาระดับสูง (สูงกว่าเมื่อเปรียบเทียบกับรหัสเครื่อง) ตรวจสอบว่าเป็นไวยากรณ์ซีแมนทิกส์การเชื่อมโยงไลบรารี่หรืออาจเพิ่มประสิทธิภาพบางอย่างจากนั้นสร้างโปรแกรมปฏิบัติการไบนารีเป็นเอาต์พุต ไฟล์เรียกทำงานนี้อาจอยู่ในรูปแบบของรหัสเครื่องหรือรหัสไบต์บางชนิดนั่นคือคำแนะนำในการกำหนดเป้าหมายเครื่องเสมือนบางชนิด การสร้างมักจะเกี่ยวข้องกับการตรวจสอบและให้การอ้างอิงตรวจสอบรหัสรวบรวมรหัสเป็นไบนาใช้การทดสอบอัตโนมัติและบรรจุไบนารี [ผลลัพธ์] และสินทรัพย์อื่น ๆ (ภาพไฟล์กำหนดค่าห้องสมุด ฯลฯ ) ในรูปแบบเฉพาะของไฟล์ที่ปรับใช้ โปรดทราบว่ากระบวนการส่วนใหญ่เป็นทางเลือกและบางกระบวนการขึ้นอยู่กับแพลตฟอร์มเป้าหมายที่คุณกำลังสร้าง ตัวอย่างเช่นการบรรจุแอ็พพลิเคชัน Java สำหรับ Tomcat จะส่งออกไฟล์. war การสร้าง Win32 ที่เรียกใช้งานได้โดยใช้รหัส C ++ สามารถส่งออกโปรแกรม. exe ได้หรืออาจทำแพ็คเกจในโปรแกรมติดตั้ง. msi

ดูตัวอย่างนี้:

public class Test {

    public static void main(String[] args) {
        int[] x=new int[-5];//compile time no error
        System.out.println(x.length);
    }}

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

Exception in thread "main" java.lang.NegativeArraySizeException
    at Test.main(Test.java:5)

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

คลาสสาธารณะ RuntimeVsCompileTime {

public static void main(String[] args) {

    //test(new D()); COMPILETIME ERROR
    /**
     * Compiler knows that B is not an instance of A
     */
    test(new B());
}

/**
 * compiler has no hint whether the actual type is A, B or C
 * C c = (C)a; will be checked during runtime
 * @param a
 */
public static void test(A a) {
    C c = (C)a;//RUNTIME ERROR
}

}

class A{

}

class B extends A{

}

class C extends A{

}

class D{

}

คุณสามารถเข้าใจโครงสร้างการคอมไพล์โค้ดจากการอ่านโค้ดที่แท้จริง โครงสร้างรันไทม์ไม่ชัดเจนถ้าคุณไม่เข้าใจรูปแบบที่ใช้

ไม่ใช่คำถามที่ดีสำหรับ SO (ไม่ใช่คำถามการเขียนโปรแกรมเฉพาะ) แต่ไม่ใช่คำถามที่ไม่ดีโดยทั่วไป

หากคุณคิดว่ามันเป็นเรื่องเล็กน้อย: แล้วการอ่านเวลากับการคอมไพล์แล้วและนี่เป็นความแตกต่างที่มีประโยชน์เมื่อใด ภาษาที่คอมไพเลอร์พร้อมใช้งานตอนรันไทม์คืออะไร? Guy Steele (ไม่มีคนบ้า ๆ บอ ๆ ) เขียน 7 หน้าใน CLTL2 เกี่ยวกับ EVAL-WHEN ซึ่งโปรแกรมเมอร์ CL สามารถใช้ควบคุมสิ่งนี้ได้ 2 ประโยคแทบจะไม่พอสำหรับความหมายที่ตัวเองเป็นยังห่างไกลจากคำอธิบาย

โดยทั่วไปแล้วมันเป็นปัญหาที่ยากลำบากที่นักออกแบบภาษาพยายามหลีกเลี่ยง พวกเขามักจะพูดว่า "นี่คือคอมไพเลอร์มันทำสิ่งที่รวบรวมเวลา; ทุกอย่างหลังจากนั้นเป็นเวลาทำงานสนุก" C ถูกออกแบบมาให้ใช้งานง่ายไม่ใช่สภาพแวดล้อมที่ยืดหยุ่นที่สุดสำหรับการคำนวณ เมื่อคุณไม่มีคอมไพเลอร์ที่รันไทม์หรือความสามารถในการควบคุมได้อย่างง่ายดายเมื่อมีการประเมินนิพจน์คุณมักจะจบลงด้วยแฮ็กในภาษาเพื่อปลอมการใช้งานทั่วไปของมาโครหรือผู้ใช้มาพร้อมกับ Design Patterns เพื่อจำลอง มีโครงสร้างที่มีประสิทธิภาพมากขึ้น ภาษาที่ใช้ง่ายสามารถเป็นเป้าหมายที่คุ้มค่าได้ แต่นั่นไม่ได้หมายความว่ามันคือการออกแบบภาษาโปรแกรมขั้นสุดท้ายทั้งหมด (ฉันไม่ได้ใช้ EVAL-WHEN มาก แต่ฉันไม่สามารถจินตนาการถึงชีวิตที่ปราศจากมัน)

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

น่าเสียดายที่ฉันไม่รู้แหล่งอ้างอิงที่ดีเกี่ยวกับเรื่องนี้ CLTL2 พูดถึงมันนิดหน่อย แต่มันก็ไม่ดีสำหรับการเรียนรู้เกี่ยวกับมัน