C ++ เฉลี่ยเคลื่อนที่

ฉันได้เอาชั้นเรียนใน C และฉันได้เรียนรู้บิตของมันด้วยตัวเองและฉันคิดว่า Im ที่จุดที่ฉันสามารถทำโปรแกรมง่ายๆ (มากกว่าเพียงไม่กี่ร้อยบรรทัดของรหัสเช่นหนังสือตัวอย่าง) แต่ I dont มีความคิดที่ดีอะไรบ้างที่จะเขียนโปรแกรม ฉันเริ่มเขียนโค้ดสำหรับ RPG แบบข้อความ แต่ฉันต้องการลองเขียนโค้ดบางอย่างมากขึ้นเช่นโปรแกรมเมอร์จริงที่โปรแกรมรหัสชีวิต ทุกคนที่ทำงานในสนามมีคำแนะนำใด ๆ ในฟอรัม Lounge มีข้อคิดเห็น นี่คือบางส่วน: hrm ฉันอาจแนะนำส่วนเสริมสำหรับแนวคิดของโครงการ หนึ่งในสิ่งที่ Ive พยายามเสมอเมื่อเรียนรู้ภาษาใหม่คือการหาโครงการที่จะทดสอบความรู้ของฉันโดยไม่ได้รับก่อนสิ่งที่ฉันอ่านหรือเข้าใจ (ทั้งหมดในขณะที่เป็นสิ่งที่สนุกและสนุกสนานในการฝึกฝนสิ่งที่ทำให้ฉันได้รางวัลเช่นการเขียนโปรแกรมที่ฉันสามารถหาประโยชน์ได้จริง) ส่วนที่สามารถส่งโครงการพร้อมกับความยากลำบากหรือ วิธีการบางอย่างในการรู้ว่าคำสั่งไหนดีที่สุดในการทำสิ่งเหล่านั้นจะเป็นความคิดที่ดี ฉันรู้ว่านี่อาจเป็นประโยชน์ไม่มากสำหรับคุณ icemanfan แต่มันอาจจะช่วยให้ผู้คนเช่นฉันซึ่งเพิ่งเริ่มต้น C. นี่คือรายการของฉันที่ฉันทำ ฮิฮิ. ฉันติดอยู่ที่หมายเลข 22. lolz ไม่สามารถรับชั้นการจัดเรียงแบบฟุ่มเฟือยโง่ ๆ ไปทำงานได้เหมือน 2 คืนตอนนี้ ถอนหายใจ ระดับเริ่มต้น 1. เขียนโปรแกรมที่ระบุแฟกทอเรียลของตัวเลขที่ป้อนโดยผู้ใช้ (ตรวจสอบเงื่อนไขทั้งหมด) (เริ่มต้น) 2. พัฒนาโปรแกรมแปลงสกุลเงิน X เป็นสกุลเงิน Y และในทางกลับกัน (เริ่มต้น) 3. เขียนโปรแกรมที่พิมพ์ต่อไปนี้ผู้ใช้จะใส่หมายเลขด้านบน: 4. เขียนโปรแกรมที่พิมพ์ต่อไปนี้ผู้ใช้จะใส่ตัวเลขด้านล่าง: 5. เขียนโปรแกรมที่ pring ออกสามเหลี่ยมต่อไปนี้ผู้ใช้ จะใส่ตัวเลขด้านล่าง: 6. พัฒนาโปรแกรมที่ใช้หมายเลขสุ่มที่สร้างขึ้นเพื่อเลือก 1 ใน 3 (หรือมากกว่า) ฟังก์ชันเพื่อแสดงให้ผู้ใช้ (เริ่มต้น) 7. คาดเดาเกม เขียนเกม c ที่ขอให้ผู้ใช้คาดเดาตัวเลขระหว่าง 1 ถึง 100 หากคุณคาดเดาได้อย่างถูกต้องก็จะบอกว่าคุณชนะ ถ้าสูงเกินไปหรือต่ำเกินไปก็จะแจ้งให้คุณทราบ (เริ่มต้น) 8. สร้างโปรแกรมที่สร้างชุด Fibonacci ขึ้นเรื่อย ๆ จนถึงจำนวน n ซึ่ง n ถูกป้อนโดยผู้ใช้ สำหรับเช่น ถ้าผู้ใช้ป้อน 10 แล้วผลลัพธ์จะเป็น: 1 1 2 3 5 8 (Beginner) 9. กำหนดจำนวนอักขระที่เป็นสระและจำนวนพยัญชนะในบรรทัดของข้อความ นอกจากนี้ยังยุติสตริงเมื่ออักขระที่ป้อนเข้าพบไม่ใช่ตัวอักษร (เริ่มต้น) 10. ค้นหารากที่ห้าของผลรวมของสี่เหลี่ยมของจำนวน 100 ODD แรกเท่านั้น (เริ่มต้น) 11. ใช้ WORD UNSCRAMBLING 4 ตัวเช่นระบุชื่อชุดอักขระ 4 ตัวในคำทั้งหมด ตัวอย่าง: คำว่า TEST สามารถถอดรหัสได้เช่น TEST, TETS, TSET, TSTE, TTSE, TTES ฯลฯ (เริ่มต้น) 12. สร้างโปรแกรมที่ช่วยให้ผู้ใช้ป้อนรัศมีเส้นผ่าศูนย์กลางหรือพื้นที่ของวงกลม โปรแกรมควรคำนวณอีก 2 ค่าจากข้อมูล (เริ่มต้น) 13. อ่านบรรทัดของข้อความและเขียนคำบรรยายออกโดยใช้ฟังก์ชัน RECURSIVE BACKWARDS (เริ่มต้น) 14. เขียนโปรแกรมเพื่อสลับเนื้อหา 3 ตัวแปรโดยไม่ต้องใช้ตัวแปรชั่วคราว (หรือพิเศษ) (เริ่มต้น) 15. เขียนโปรแกรมที่จะย้อนกลับไปเป็นตัวเลขในจำนวนเต็มคือ 326 จะกลายเป็น 623 เป็นต้น (เริ่มต้น) 16. โปรแกรมจะบอกให้ผู้ใช้แต่ละครั้งว่าเขาคาดเดาว่าสูงหรือต่ำ ผู้ใช้ชนะเกมเมื่อจำนวนที่คาดเดาเท่ากับจำนวนที่สร้างขึ้นแบบสุ่ม (เริ่มต้น) 17. เขียนโปรแกรมเพื่อจำลองเครื่องคำนวณแบบง่ายๆ ควรยอมรับจำนวนสองหมายเลขจากผู้ใช้พร้อมกับการดำเนินการที่จำเป็นที่จะดำเนินการ การบวกลบหารและการคูณคือการดำเนินการขั้นพื้นฐานที่ควรจะนำมาใช้ รู้สึกเป็นอิสระที่จะใช้การดำเนินการอื่น ๆ (Beginner) 18 กำหนดจำนวนเงินที่อยู่ในธนาคารลูกหมูที่มีหลาย 50 เหรียญ paise, 25 เหรียญ paise, เหรียญ 20 paise, 10 เหรียญและเหรียญ paise 5 เหรียญ ใช้ค่าต่อไปนี้เพื่อทดสอบโปรแกรมของคุณ เหรียญห้าเหรียญ 50 เหรียญสามเหรียญ 25 เหรียญเหรียญสองเหรียญ 20 เหรียญเหรียญละเหรียญ 10 เหรียญและเหรียญสิบห้าเหรียญ 5 เหรียญ (Beginner) 19. สร้างโปรแกรมตรวจสอบ Palindrome แบบง่ายๆ โปรแกรมควรอนุญาตให้ผู้ใช้ป้อนสตริงและตรวจสอบว่าสตริงที่กำหนดเป็น palindrome หรือไม่ เฉพาะตัวเลขและตัวอักษรเท่านั้นที่ควรได้รับการพิจารณาในขณะที่ตรวจสอบ palindromes - ควรละเว้นอักขระอื่น ๆ (เริ่มต้น) 20. เขียนโปรแกรมที่จะช่วยให้คุณสามารถใส่คะแนนและน้ำหนักของนักเรียนได้ โปรแกรมควรคำนวณค่าถัวเฉลี่ยถ่วงน้ำหนักและคะแนนตามข้อมูลที่ป้อนโดยผู้ใช้ (Beginner) Intermediate 21. เขียนโปรแกรมที่จะพิมพ์ทุกคู่ของตัวเลขสำคัญที่มีผลรวมเท่ากับจำนวนที่ป้อนโดยผู้ใช้ (แนะนำโดย Aniseed) (ระดับกลาง) 22. สร้างฐานการจำแนกสัตว์ตามราชอาณาจักรสัตว์ (สำหรับการฝึกฝนการใช้ชนชั้นท้องถิ่น) 23. เขียนโปรแกรมตอบคำถามซึ่งเรียกค้นคำถามและคำตอบจากไฟล์ จากนั้นให้ผู้ใช้สามารถใช้ quizcount point และ return score ได้ (ระดับกลาง) 24. เขียนโปรแกรมที่ยอมรับ XHTML, แยกวิเคราะห์และลบแท็กออก จากนั้นจะพิมพ์ข้อความที่เหลือ (Intermediate) 25. เขียนโปรแกรมที่ทำเพิ่ม, ลบ, คูณเมทริกซ์ ขนาดของทั้งเมทริกซ์จะถูกระบุโดยผู้ใช้ (การจัดสรรหน่วยความจำแบบไดนามิกที่จำเป็น) การใช้โครงสร้างหรือคลาสเพื่อกำหนดเมตริกซ์จะเป็นความคิดที่ดี (ปานกลาง) 26. เขียนโปรแกรมที่จะทำหน้าที่ย้ายแฟ้มจากที่หนึ่งไปยังอีกที่หนึ่ง เส้นทางต้นทางและปลายทางจะถูกป้อนโดยผู้ใช้ ดำเนินการตรวจสอบข้อผิดพลาดที่จำเป็นและจัดการกับข้อยกเว้นตามลำดับ (ระดับกลาง) 27. สร้างคลาสรายการที่เชื่อมโยงที่ซับซ้อน คุณควรจะสามารถแทรกและลบโหนดได้จากทุกที่ในรายการและโหนดควรมีตัวชี้ไปยังโหนดทั้งด้านหน้าและด้านหลัง (ขั้นกลาง) 28. สร้างโปรแกรมที่ใช้ฐานข้อมูลใน C. เขตข้อมูลจะถูกเข้ารหัสด้วยฮาร์ดดิสก์และข้อมูลจะถูกบันทึกไว้ในไฟล์ไบนารี แม้ว่าจะไม่ใช่ความยืดหยุ่นจริงๆ แต่คุณไม่ต้องอาศัยไลบรารีภายนอกหรือฟังก์ชันใด ๆ (ปานกลาง) ผู้เชี่ยวชาญ 1. ใช้ strstr ของคุณเอง 2. เขียนโปรแกรมที่ทำตัวเหมือนนักวางแผนส่วนบุคคล ซึ่งผู้ใช้สามารถป้อนข้อมูลลงในกิจกรรมบันทึกสิ่งที่ต้องทำในวันที่กำหนด 3. โปรแกรม Tic Tac Toe (ใช้สิ่งที่ง่ายเช่น ROT13 5 เขียนโปรแกรมหนังสือ phoneaddress กับข้อมูลที่บันทึกในไฟล์ไบนารีผู้ใช้ควรจะสามารถเพิ่มการถอดเปลี่ยนข้อมูล 6 เขียนโปรแกรมเงินเดือนที่เรียบง่ายที่จะรวมถึงอัตราค่าจ้าง และชั่วโมงการทำงานสำหรับพนักงาน 7 สร้างชั้นเรียนไม่กี่ที่เล่นไพ่รุ่นแล้วใช้กรอบการทำงานนี้เพื่อสร้างเกมการ์ดที่คุณชื่นชอบ Blackjack .. ฯลฯ (ผู้เชี่ยวชาญ) 8. สร้างชั้นเรียนไม่กี่แบบที่หมากรุกชิ้นจากนั้นพัฒนา เกมหมากรุกจริง (Expert) 9. สร้างต้นไม้ไบนารีที่มีฟังก์ชันการค้นหาและการเรียงลำดับ (Expert) 10. สร้าง Quine นั่นคือโปรแกรมที่พิมพ์ซอร์สโค้ดของตนเอง (Expert) 11. ใช้งานของคุณเอง รุ่นของไลบรารีแม่แบบมาตรฐาน (ผู้เชี่ยวชาญ) กราฟิก 1. เขียนโปรแกรมเพื่อวาดรูปสี่เหลี่ยมผืนผ้าวงรีสี่เหลี่ยมสี่เหลี่ยมผืนผ้าวงกลมจุดและเส้นตามข้อมูลของผู้ใช้ (เริ่มต้น) 2. เขียนโปรแกรมเลียนแบบ Microsoft Paint ควร สามารถสลับระหว่างเครื่องมือต่างๆ (วงกลมสี่เหลี่ยมผืนผ้ายางลบ) โดยใช้ pre-de ปรับคีย์ตอก Intermediate 3. เขียนโปรแกรมเพื่อทำกราฟ x-y แบบง่ายๆสำหรับฟังก์ชันแฮ็ปซิ่ง (เช่น ycos (x)) ควรขยายส่วนใดส่วนหนึ่งของกราฟ - ปานกลาง เขียนโปรแกรมเพื่อแสดงกราฟสมการที่กำหนดในรูปแบบ yf (x) และช่วงสำหรับ x เป็นอาร์กิวเมนต์บรรทัดคำสั่ง (เช่น mygraphplotter - eqyxx - xmin-10, - xmax10) - ผู้เชี่ยวชาญ (PS: มีส่วนเกี่ยวข้องกับการแก้สมการมากกว่ากราฟิก) 5. เขียนเกมแบบแบ่งอิฐแบบคลาสสิก เช่น. ดูบอล DX ผู้เชี่ยวชาญ แก้ไขครั้งล่าสุดเมื่อวันที่ 11 สิงหาคม 2551 เวลา 3:04 น. ตามเวลา UTC โดยทั่วไป C และ Java สามารถทำได้เร็วหรือเร็วเนื่องจากคอมไพเลอร์ JIT ซึ่งเป็นคอมไพเลอร์ที่รวบรวม IL ของคุณเป็นครั้งแรกที่รัน - สามารถทำให้การเพิ่มประสิทธิภาพเป็นไปได้ว่าโปรแกรมที่คอมไพล์แล้ว ไม่สามารถเพราะสามารถสอบถามเครื่องได้ สามารถตรวจสอบได้ว่าเครื่องนี้เป็น Intel หรือ AMD Pentium 4, Core Solo หรือ Core Duo หรือถ้าสนับสนุน SSE4 เป็นต้นโปรแกรม AC ต้องได้รับการรวบรวมมาก่อนโดยปกติจะมีการเพิ่มประสิทธิภาพแบบผสมเพื่อให้เครื่องทำงานได้ดีในทุกเครื่อง แต่ไม่ได้ (เช่นชุดประมวลผลชุดคำสั่งและฮาร์ดแวร์อื่น ๆ ) นอกจากนี้คุณสมบัติภาษาบางอย่างให้คอมไพเลอร์ใน C และ Java เพื่อให้ข้อสันนิษฐานเกี่ยวกับรหัสของคุณที่ช่วยให้การเพิ่มประสิทธิภาพบางส่วนออกไปที่ arent เพียงปลอดภัยสำหรับคอมไพเลอร์ CC จะทำ เมื่อคุณเข้าถึงคำแนะนำ theres มาก optimizations ที่ arent เพียงปลอดภัย นอกจากนี้ Java และ C สามารถจัดสรรกองได้อย่างมีประสิทธิภาพมากกว่า C เนื่องจากชั้นของสิ่งที่เป็นนามธรรมระหว่างตัวเก็บรวบรวมขยะกับโค้ดของคุณช่วยให้สามารถบีบอัดฮีปทั้งหมดได้ในครั้งเดียว (การดำเนินการที่ค่อนข้างแพง) ตอนนี้ฉันลาดเทพูดสำหรับ Java ในจุดต่อไปนี้ แต่ฉันรู้ว่า C ตัวอย่างเช่นจริงจะลบวิธีการและวิธีการเรียกเมื่อรู้ว่าร่างกายของวิธีการที่ว่างเปล่า และจะใช้ตรรกะแบบนี้ตลอดรหัสของคุณ ดังนั้นคุณสามารถดูได้มีเหตุผลมากมายที่ทำให้การใช้งาน C หรือ Java บางอย่างเร็วขึ้น ตอนนี้ทั้งหมดนี้กล่าวว่าการเพิ่มประสิทธิภาพเฉพาะสามารถทำใน C ที่จะพัดไปสิ่งที่คุณสามารถทำอะไรกับ C โดยเฉพาะอย่างยิ่งในขอบเขตกราฟิกและทุกเวลาที่คุณอยู่ใกล้กับฮาร์ดแวร์ คำแนะนำทำสิ่งมหัศจรรย์ที่นี่ ดังนั้นขึ้นอยู่กับสิ่งที่คุณเขียนฉันจะไปกับหนึ่งหรืออื่น ๆ แต่ถ้า youre เขียนสิ่งที่ไม่ขึ้นอยู่กับฮาร์ดแวร์ (driver, วิดีโอเกม ฯลฯ ) ฉัน wouldnt กังวลเกี่ยวกับประสิทธิภาพของ C (อีกครั้งลาดเทพูดคุยเกี่ยวกับ Java) ทำได้ไม่ดี ด้านหนึ่งของ Java Swati ชี้ให้เห็นว่าเป็นบทความที่ดี: JIT vs. Static Compiler ตามที่กล่าวไว้ในบทความก่อนหน้านี้ JIT สามารถรวบรวม ILbytecode ลงในโค้ดเนมได้ในขณะรันไทม์ ค่าใช้จ่ายของที่ถูกกล่าวถึง แต่ไม่สรุป: JIT มีปัญหาใหญ่อย่างหนึ่งคือไม่สามารถคอมไพล์ทุกอย่างได้: การรวบรวม JIT ต้องใช้เวลาดังนั้น JIT จะคอมไพล์เฉพาะบางส่วนของโค้ดเท่านั้นในขณะที่คอมไพเลอร์แบบสแตติกจะผลิตเต็มรูปแบบ ไบนารีดั้งเดิม: สำหรับโปรแกรมบางประเภทคอมไพเลอร์แบบคงที่จะทำงานได้เร็วกว่า JIT แน่นอนว่า C (หรือ Java หรือ VB) มักจะทำงานได้เร็วกว่า C (ถ้าเพียงเพราะ C มีความหมายที่ซับซ้อนและ C มาตรฐานห้องสมุดในขณะที่น่าสนใจและมีประสิทธิภาพค่อนข้างเลวเมื่อเทียบกับเต็ม ขอบเขตของไลบรารีมาตรฐานจากหรือ Java) ดังนั้นโดยทั่วไปแล้วความแตกต่างระหว่าง C และ Java JIT จะมองเห็นได้สำหรับผู้ใช้ส่วนใหญ่และสำหรับไบนารีที่มีความสำคัญมากคุณสามารถเรียกการประมวลผล C จาก C หรือ Java ( ถ้าชนิดของสายพื้นเมืองนี้สามารถเป็นค่าใช้จ่ายได้มากในตัวเอง) C metaprograming โปรดทราบว่าโดยปกติแล้วคุณกำลังเปรียบเทียบโค้ดรันไทม์ C กับเทียบเท่าใน C หรือ Java แต่ C มีคุณลักษณะหนึ่งที่สามารถทำงานได้ดีกว่า JavaC ออกจากกล่องนั่นคือ template metaprograming: การประมวลผลโค้ดจะดำเนินการในเวลารวบรวม (ดังนั้นการเพิ่มเวลาในการรวบรวมอย่างมากมาย) ส่งผลให้รันไทม์ศูนย์ (หรือเกือบเป็นศูนย์) ฉันยังไม่เห็นผลกระทบในชีวิตจริงนี้ (ฉันเล่นเฉพาะกับแนวคิด แต่แล้วความแตกต่างคือวินาทีของการดำเนินการสำหรับ JIT และศูนย์สำหรับ C) แต่นี้เป็นมูลค่าการกล่าวขวัญข้างแม่แบบความเป็นจริง metaprograming ไม่ได้ จิ๊บจ๊อย แก้ไข 2011-06-10: ใน C การเล่นกับประเภทจะกระทำในเวลารวบรวมซึ่งหมายถึงการสร้างโค้ดทั่วไปซึ่งเรียกใช้โค้ดที่ไม่ใช่รหัสทั่วไป (เช่นตัวแยกวิเคราะห์ทั่วไปจากสตริงไปเป็น T, เรียก API ไลบรารีมาตรฐานสำหรับประเภท T ที่รู้จัก, และทำให้ parser ได้อย่างง่ายดายขยายโดยผู้ใช้) เป็นเรื่องง่ายมากและมีประสิทธิภาพมากในขณะที่เทียบเท่าใน Java หรือ C เจ็บปวดที่ดีที่สุดในการเขียนและจะช้าและแก้ไขที่รันไทม์แม้ชนิดเป็นที่รู้จักกันในเวลารวบรวม, หมายถึงความหวังเดียวของคุณคือการที่ JIT จะแทรกแซงสิ่งทั้งปวง แก้ไข 2011-09-20: ทีมงานหลัง Blitz (Homepage. วิกิพีเดีย) ไปด้วยวิธีดังกล่าวและเห็นได้ชัดว่าเป้าหมายของพวกเขาคือการเข้าถึงผลการคำนวณของ FORTRAN ในการคำนวณทางวิทยาศาสตร์โดยการย้ายให้มากที่สุดเท่าที่จะเป็นไปได้จากการรันไทม์ในการรวบรวมเวลาผ่าน C metaprogramming แม่แบบ . ดังนั้นฉันยังไม่เห็นผลกระทบในชีวิตจริงในส่วนที่ฉันเขียนข้างต้นดูเหมือนจะมีอยู่ในชีวิตจริง การใช้หน่วยความจำ C C มีการใช้หน่วยความจำแตกต่างจาก JavaC และมีข้อได้เปรียบที่แตกต่างกัน ไม่ว่าการเพิ่มประสิทธิภาพของ JIT จะไม่มีอะไรจะไปได้อย่างรวดเร็วเช่นเดียวกับการเข้าถึงตัวชี้โดยตรงไปยังหน่วยความจำ (ให้ละเว้นการเก็บแคชของโปรเซสเซอร์เป็นต้น) ดังนั้นถ้าคุณมีข้อมูลอยู่ในหน่วยความจำเข้าถึงได้ผ่านตัวชี้ C (ตัวชี้ C ให้ให้ซีซาร์ครบกำหนด) จะไปเร็วกว่าใน JavaC และ C มี RAII ซึ่งทำให้การประมวลผลเป็นเรื่องง่ายกว่าใน C หรือแม้แต่ใน Java C ไม่จำเป็นต้องใช้ขอบเขตของการดำรงอยู่ของวัตถุ และ C ไม่มีประโยคสุดท้าย นี่ไม่ใช่ข้อผิดพลาด และแม้จะมี C แบบดั้งเดิมเหมือน C โครงสร้างที่ stack จะไม่มีค่าใช้จ่ายอะไรในการจัดสรรและการทำลายและจะต้องไม่มี GC ทำงานในหัวข้อที่เป็นอิสระในการทำความสะอาด สำหรับการกระจายตัวของหน่วยความจำตัวจัดสรรหน่วยความจำในปี 2008 ไม่ใช่ตัวจัดสรรหน่วยความจำเก่าจากปีพ. ศ. 2523 ซึ่งมักจะถูกเปรียบเทียบกับการจัดสรร GC: C ไม่สามารถย้ายไปอยู่ในหน่วยความจำจริง แต่เช่นเดียวกับระบบแฟ้ม Linux: ใครต้องการจัดระเบียบฮาร์ดดิสก์เมื่อ fragmentation ไม่ได้เกิดขึ้นการใช้ allocator ที่ถูกต้องสำหรับงานที่เหมาะสมควรเป็นส่วนหนึ่งของชุดเครื่องมือสำหรับนักพัฒนาซอฟต์แวร์ C ตอนนี้การเขียนตัวจัดสรรไม่ใช่เรื่องง่ายแล้วส่วนใหญ่ของเรามีสิ่งที่ดีกว่าที่จะทำและสำหรับการใช้งานส่วนใหญ่ RAII หรือ GC จะดีเกินกว่า แก้ไข 2011-10-04: สำหรับตัวอย่างเกี่ยวกับตัวจัดสรรที่มีประสิทธิภาพ: บนแพลตฟอร์ม Windows ตั้งแต่ Vista สแต็คการแยกส่วนต่ำจะเปิดใช้งานโดยค่าเริ่มต้น สำหรับรุ่นก่อนหน้า LFH สามารถใช้งานได้โดยการเรียกใช้ฟังก์ชัน HeapSetInformation ของ WinAPI) ใน OSes อื่น ๆ ตัวจัดสรรอื่น ๆ มีให้ (ดู secure. wikimedia. orgwikipediaenwikiMalloc สำหรับรายการ) ขณะนี้รูปแบบหน่วยความจำค่อนข้างซับซ้อนมากขึ้นด้วยการเพิ่มขึ้นของเทคโนโลยี multicore และ multithreading ในสาขานี้ผมคิดว่ามีข้อได้เปรียบและ Java ผมบอกว่าถือพื้นดินบน ง่ายสำหรับบางคนในแฮกเกอร์โลหะเปลือยกายเพื่อยกย่องเขาใกล้รหัสเครื่อง แต่ตอนนี้การผลิตแอสเซมบลีที่ดีกว่าด้วยการให้คอมไพเลอร์ทำงานได้ยากขึ้น สำหรับ C คอมไพเลอร์ก็มักจะดีกว่าแฮกเกอร์ตั้งแต่ทศวรรษที่ผ่านมา สำหรับ C และ Java นี้จะยิ่งง่ายขึ้น ยังคงมาตรฐานใหม่ C0x จะกำหนดรูปแบบหน่วยความจำง่ายๆให้กับคอมไพเลอร์ C ซึ่งจะเป็นมาตรฐาน (และทำให้ง่ายขึ้น) รหัส multiprocessingparallelthreading ที่มีประสิทธิภาพใน C และทำให้การเพิ่มประสิทธิภาพเป็นเรื่องง่ายและปลอดภัยยิ่งขึ้นสำหรับคอมไพเลอร์ แต่แล้วเห็นได้ชัดในบางสองสามปีถ้าคำสัญญาของตนเป็นจริง CCLI vs. CVB หมายเหตุ: ในส่วนนี้ฉันพูดถึง CCLI นั่นคือ C ที่โฮสต์โดยไม่ใช่ native C. สัปดาห์ที่ผ่านมาฉันได้รับการฝึกอบรมเกี่ยวกับการเพิ่มประสิทธิภาพและพบว่าคอมไพเลอร์แบบคงที่มีความสำคัญอยู่แล้ว สำคัญกว่า JIT รหัสเดียวกันที่รวบรวมไว้ใน CCLI (หรือบรรพบุรุษของ Managed C) อาจเร็วกว่าโค้ดที่ผลิตใน C (หรือ VB ที่คอมไพเลอร์สร้าง IL เดียวกันกับ C) เนื่องจากคอมไพเลอร์แบบคงที่ C ดีกว่ามากในการสร้างโค้ดที่ได้รับการปรับปรุงแล้วดีกว่า Cs ตัวอย่างเช่นฟังก์ชัน inlining ในถูก จำกัด ไว้สำหรับฟังก์ชันที่มี bytecode น้อยหรือมีขนาดเท่ากับ 32 ไบต์ ดังนั้นโค้ดบางตัวใน C จะสร้าง accessor ขนาด 40 byte ซึ่งโดย JIT จะไม่เคยมีมาก่อน รหัสเดียวกันใน CCLI จะสร้างตัวเชื่อม 20 ไบต์ซึ่งจะถูกแทรกโดย JIT อีกตัวอย่างหนึ่งคือตัวแปรชั่วคราวที่เรียบเรียงโดยคอมไพเลอร์ C ในขณะที่ยังคงถูกกล่าวถึงใน IL ที่ผลิตโดยคอมไพเลอร์ C การเพิ่มประสิทธิภาพการรวบรวมข้อมูลแบบคงที่ C จะส่งผลให้โค้ดน้อยลงจึงทำให้การเพิ่มประสิทธิภาพ JIT ก้าวร้าวมากขึ้นอีกครั้ง เหตุผลนี้ถูกสันนิษฐานว่าเป็นคอมไพเลอร์ CCLI จริงประโยชน์จากเทคนิคการเพิ่มประสิทธิภาพมากมายจาก C native compiler ข้อสรุป แต่เท่าที่ฉันเห็นมัน C หรือ Java ทั้งหมดในทุกเดิมพันดีขึ้น ไม่ใช่เพราะเร็วกว่า C แต่เนื่องจากเมื่อคุณเพิ่มคุณสมบัติของพวกเขาพวกเขาจะมีประสิทธิผลมากขึ้นต้องได้รับการฝึกอบรมน้อยลงและมีไลบรารีมาตรฐานที่สมบูรณ์กว่า C. และส่วนใหญ่ของโปรแกรมจะแตกต่างกันไป หรืออีกวิธีหนึ่ง) จะไม่สำคัญนัก แก้ไข (2011-06-06) ประสบการณ์ของฉันใน C ฉันมีตอนนี้ 5 เดือนเกือบพิเศษ C มืออาชีพ Coding (ซึ่งเพิ่มขึ้นไป CV ของฉันแล้วเต็ม C และ Java และสัมผัสของ CCLI) ฉันเล่นกับ WinForms (Ahem.) และ WCF (เย็น) และ WPF (Cool ทั้ง XAML และ Raw C. WPF เป็นเรื่องง่ายดังนั้นฉันเชื่อว่า Swing ไม่สามารถเทียบได้) และ C 4.0 สรุปได้ว่าในขณะที่มันง่ายกว่าที่จะผลิตรหัสที่ทำงานใน CJava กว่า C มากขึ้นยากที่จะผลิตรหัสที่แข็งแกร่งปลอดภัยและมีประสิทธิภาพใน C (และยากยิ่งกว่าใน Java) กว่าใน C. เหตุผลที่อุดมสมบูรณ์ แต่มัน สามารถสรุปได้โดย: Generics ไม่ได้มีประสิทธิภาพเท่ากับเทมเพลต (พยายามเขียนวิธีแยกวิเคราะห์ (Parse method) ที่มีประสิทธิภาพ (จากสตริงไปที่ T) หรือเทียบเท่าที่มีประสิทธิภาพในการเพิ่ม :: lexicalcast ใน C เพื่อทำความเข้าใจกับปัญหา) RAII ยังคงไม่เหมือนใคร (ใช่ฉันได้เพื่อจัดการกับปัญหาที่) และจะจัดการกับหน่วยความจำแม้ Cs ใช้ไม่ง่ายและมีประสิทธิภาพเพราะการเขียนที่ถูกต้องทิ้งการใช้งานเป็นเรื่องยาก) C อ่านอย่างเดียวและ Java สุดท้ายไม่มีที่ไหนเลยที่เป็นประโยชน์เป็น Cs const (Theres ไม่มีทางที่คุณจะสามารถเปิดเผยข้อมูลที่อ่านได้เพียงอย่างเดียว (Tree of Nodes ตัวอย่างเช่น) ใน C โดยไม่มีการทำงานมากนักในขณะที่คุณสมบัติในตัวของ C. ข้อมูลที่ไม่เปลี่ยนรูปเป็นทางออกที่น่าสนใจ แต่ไม่ใช่ทุกอย่างที่สามารถเปลี่ยนแปลงได้ ไม่พอโดยไกล) ดังนั้น C ยังคงเป็นภาษาที่น่ารื่นรมย์ตราบเท่าที่คุณต้องการสิ่งที่ทำงาน แต่เป็นภาษาที่น่าผิดหวังในขณะที่คุณต้องการสิ่งที่ทำงานได้อย่างปลอดภัยและเสมอไป Java มีความผิดหวังมากขึ้นเนื่องจากมีปัญหาเดียวกันมากกว่า C และอื่น ๆ : ขาด Cs เทียบเท่ากับคำหลักเพื่อนร่วมงานที่มีฝีมือมากของฉันใช้เวลามากเกินไปเพื่อให้แน่ใจว่าทรัพยากรที่ปลดปล่อยอย่างถูกต้องในขณะที่เทียบเท่าใน C จะ เป็นเรื่องง่าย (ใช้ destructors และ smart pointers) ดังนั้นฉันเดาการเพิ่มผลผลิต CJavas จะมองเห็นได้สำหรับโค้ดส่วนใหญ่ จนถึงวันที่คุณต้องการรหัสให้สมบูรณ์แบบที่สุด วันนั้นคุณจะรู้ความเจ็บปวด (คุณไม่เคยเชื่อสิ่งที่ถามจากเซิร์ฟเวอร์และแอป GUI ของเรา) เกี่ยวกับ Server-side Java และ C ฉันยังคงติดต่อกับทีมงานเซิร์ฟเวอร์ (ฉันทำงาน 2 ปีท่ามกลางพวกเขาก่อนที่จะกลับไปที่ทีม GUI) ที่ด้านอื่น ๆ ของอาคารและฉันได้เรียนรู้สิ่งที่น่าสนใจ ปีที่ผ่านมามีแนวโน้มที่จะมีปพลิเคชันเซิร์ฟเวอร์ Java ถูก destined เพื่อแทนที่ปพลิเคชันเซิร์ฟเวอร์ C เก่าเป็น Java มีจำนวนมากกรอบงานและง่ายต่อการรักษาปรับใช้ ฯลฯ ฯลฯ จนกว่าปัญหาของแฝงต่ำ เลี้ยงดูหัวที่น่าเกลียดเมื่อเดือนที่แล้ว จากนั้นแอ็พพลิเคชันเซิร์ฟเวอร์ Java ไม่ว่าความพยายามด้านการเพิ่มประสิทธิภาพของทีม Java ของเราจะมีผลดีเพียงใดและหายสาบสูญไปกับการแข่งขันกับเซิร์ฟเวอร์ C ที่เก่าซึ่งไม่ได้รับการปรับแต่งให้ดีจริงๆ ขณะนี้การตัดสินใจคือการรักษาเซิร์ฟเวอร์ Java สำหรับการใช้งานทั่วไปโดยที่ประสิทธิภาพการทำงานในขณะที่ยังคงมีความสำคัญไม่ได้เกี่ยวข้องกับเป้าหมายที่มีความหน่วงในระดับต่ำและทำให้แอพพลิเคชันเซิร์ฟเวอร์ C ทำงานได้รวดเร็วขึ้นสำหรับความต้องการในระดับแฝงต่ำและมีความล่าช้าต่ำมาก ข้อสรุปไม่มีอะไรที่ทำได้ง่ายอย่างที่คาดไว้ Java และยิ่งกว่านั้น C เป็นภาษาที่น่าสนใจพร้อมกับไลบรารีและกรอบมาตรฐานที่กว้างขวางซึ่งคุณสามารถโค้ดได้อย่างรวดเร็วและมีผลเร็ว ๆ นี้ แต่เมื่อคุณต้องการพลังดิบการเพิ่มประสิทธิภาพที่มีประสิทธิภาพและเป็นระบบการสนับสนุนคอมไพเลอร์ที่แข็งแกร่งคุณลักษณะภาษาที่มีประสิทธิภาพและความปลอดภัยแน่นอน Java และ C ทำให้ยากที่จะชนะขาดหายไปสุดท้าย แต่ที่สำคัญร้อยละของคุณภาพที่คุณต้องอยู่เหนือการแข่งขัน ราวกับว่าคุณต้องการเวลาน้อยลงและนักพัฒนาที่มีประสบการณ์น้อยกว่าใน CJava กว่า C ในการผลิตรหัสคุณภาพเฉลี่ย แต่ในทางกลับกันช่วงเวลาที่คุณต้องการความยอดเยี่ยมในการสร้างรหัสคุณภาพที่สมบูรณ์แบบก็เริ่มง่ายขึ้นและเร็วขึ้นเพื่อให้ได้ผลลัพธ์ที่ถูกต้อง C. แน่นอนว่านี่คือการรับรู้ของฉันเองบางทีอาจ จำกัด เฉพาะความต้องการเฉพาะของเรา แต่ก็ยังคงเป็นสิ่งที่เกิดขึ้นในวันนี้ทั้งในทีม GUI และทีมฝั่งเซิร์ฟเวอร์ แน่นอนว่าควรอัปเดตโพสต์นี้หากมีสิ่งใหม่ ๆ เกิดขึ้น แก้ไข (2011/06/22) เราพบว่าในแง่ของประสิทธิภาพ C ชนะออกโดยขอบขนาดใหญ่ อย่างไรก็ตามยังต้องใช้ความพยายามในการปรับแต่งที่หลากหลายมากที่สุดซึ่งในหลายระดับได้กระทำในระดับที่ซับซ้อนซึ่งจะไม่สามารถใช้ได้กับโปรแกรมเมอร์เฉลี่ย . รุ่น Java อาจใช้งานได้ง่าย แต่ยากที่จะวิเคราะห์ประสิทธิภาพ โดยเฉพาะผลกระทบที่เกิดขึ้นรอบ ๆ การเก็บรวบรวมขยะนั้นมีความซับซ้อนและยากที่จะปรับแต่ง แก้ไข (2011-09-20) คำที่กำลังดำเนินอยู่ที่ Facebook นั่นคือโค้ด C ที่เขียนอย่างถูกต้องทำงานได้รวดเร็วซึ่งจะเน้นย้ำถึงความพยายามมหาศาลที่ใช้ในการเพิ่มประสิทธิภาพ PHP และโค้ด Java Paradoxically, รหัส C เป็นเรื่องยากที่จะเขียนกว่าในภาษาอื่น ๆ แต่รหัสที่มีประสิทธิภาพเป็นจำนวนมากง่ายต่อการเขียนใน C กว่าในภาษาอื่น ๆ quot การประมวลผลโค้ดจะดำเนินการที่ timequot รวบรวม ดังนั้นการทำ metaprogramming เทมเพลตจะทำงานได้เฉพาะในโปรแกรมจึงมีให้ในเวลารวบรวมข้อมูลซึ่งมักไม่ใช่กรณีเช่น ไม่สามารถเขียนไลบรารีนิพจน์ทั่วไปที่มีประสิทธิภาพในวานิลลาซีเพราะไม่มีความสามารถในการสร้างโค้ดรันไทม์ (เป็นส่วนสำคัญของการทำ metaprogramming) ฉันต้องการชี้ไปที่ซีรีส์ Rico (และ Raymond) ได้เปรียบเทียบ C และ C รุ่นของพจนานุกรมภาษาจีน. การค้นหา google นี้จะช่วยให้คุณสามารถอ่านด้วยตัวคุณเอง แต่ผมชอบข้อมูลสรุปของ Ricos ดังนั้นฉันรู้สึกอับอายด้วยความพ่ายแพ้ของฉันแทบไม่ได้ โค้ดที่ได้รับการจัดการมีผลดีมากสำหรับแทบไม่มีความพยายามใด ๆ เพื่อเอาชนะเรย์มอนด์ที่ได้รับการจัดการ: เขียนไฟล์ IO ของตัวเองเขียนคลาสสตริงของตัวเองเขียนตัวจัดสรรของตัวเองเขียนการทำแผนที่ระหว่างประเทศของตัวเองแน่นอนว่าเขาใช้ไลบรารีระดับล่างที่มีอยู่ในการทำเช่นนี้ แต่ยังคงทำงานอยู่เป็นจำนวนมาก คุณสามารถเรียกสิ่งที่เหลือโปรแกรม STL ฉันไม่คิดอย่างนั้นฉันคิดว่าเขาเก็บ std :: vector ชั้นซึ่งในที่สุดก็ไม่เคยมีปัญหาและเขายังคงค้นหาฟังก์ชัน ทุกสิ่งทุกอย่างที่น่าสนใจก็หายไป ดังนั้น yup คุณสามารถชนะ CLR แน่นอน Raymond สามารถทำให้โปรแกรมของเขาทำงานได้เร็วขึ้นฉันคิดว่า น่าสนใจเวลาในการแยกวิเคราะห์ไฟล์ตามที่รายงานโดยโปรแกรมจับเวลาภายในทั้งสองโปรแกรมเป็นเรื่องเกี่ยวกับเดียวกัน - 30ms สำหรับแต่ละ ความแตกต่างอยู่ในค่าใช้จ่าย สำหรับฉันบรรทัดล่างคือว่าต้องใช้ 6 การแก้ไขสำหรับรุ่นที่ไม่มีการจัดการเพื่อเอาชนะรุ่นที่ได้รับการจัดการซึ่งเป็นพอร์ตที่เรียบง่ายของรหัสที่ไม่มีการจัดการต้นฉบับ ถ้าคุณต้องการทุกบิตสุดท้ายของประสิทธิภาพ (และมีเวลาและความเชี่ยวชาญที่จะได้รับมัน) คุณจะต้องไปจัดการ แต่สำหรับฉันฉันจะสั่งซื้อของความได้เปรียบขนาดฉันมีในรุ่นแรกกว่า 33 ฉันได้รับถ้าฉัน ลอง 6 ครั้ง ก่อนอื่นถ้าเราดูโค้ดของ Raymond Chen เขาก็ไม่เข้าใจโครงสร้าง C หรือข้อมูลเป็นอย่างดี รหัสของเขาเกือบถึงตรงสำหรับระดับต่ำรหัส C แม้ในกรณีที่รหัส C ไม่มีประโยชน์ประสิทธิภาพ (มันก็น่าจะเป็นประเภทของความไม่ไว้วางใจและอาจจะขาดความรู้เกี่ยวกับการใช้ profilers) เขายังล้มเหลวในการทำความเข้าใจกับวิธีการใช้อัลกอริธึมมากที่สุดในการใช้พจนานุกรม (เขาใช้ std :: หาเพื่อประโยชน์ของพระคริสต์) หากมีบางอย่างที่ดีเกี่ยวกับ Java, Python, C เป็นต้น - พวกเขาทั้งหมดมีพจนานุกรมที่มีประสิทธิภาพมาก ndash stinky472 Feb 28 12 at 18:26 การทดลองหรือแม้แต่ std :: map จะให้ผลดีกว่า C หรือแม้แต่ตารางแฮช สุดท้ายพจนานุกรมก็คือประเภทของโปรแกรมที่ได้รับประโยชน์สูงสุดจากไลบรารีและเฟรมระดับสูง มันไม่ได้แสดงให้เห็นความแตกต่างในภาษามากเท่ากับห้องสมุดที่เกี่ยวข้อง (ซึ่งผมจะบอกว่า C มีความสมบูรณ์มากขึ้นและมีเครื่องมือมากขึ้นสำหรับงานนี้) แสดงโปรแกรมที่ใช้จัดการหน่วยความจำขนาดใหญ่ในการเปรียบเทียบเช่นรหัส matrixvector ขนาดใหญ่ ที่จะชำระนี้ค่อนข้างรวดเร็วแม้ว่าในกรณีนี้ coders don't ทราบว่า ndash stinky472 28 กุมภาพันธ์ที่ 18:29 มันไม่มากที่คุณกำลังรวบรวมการเพิ่มประสิทธิภาพ CPU แต่คุณกำลังรวบรวมการเพิ่มประสิทธิภาพเส้นทางรันไทม์ ถ้าคุณพบว่าวิธีการที่มักเรียกว่ามีพารามิเตอร์เฉพาะคุณสามารถคอมไพล์ขั้นตอนนั้นด้วยพารามิเตอร์ดังกล่าวเป็นค่าคงที่ซึ่งอาจเป็นไปได้ (ในกรณีของ boolean ที่ควบคุมการไหลเวียน) จะทำให้ชิ้นงานขนาดมหึมาหลุดออกไป C ไม่สามารถมาใกล้เคียงกับการเพิ่มประสิทธิภาพแบบนี้ได้ ndash Bill K 09:09 at 17:42 ดังนั้น JIT ทำที่ recompiling ประจำเพื่อใช้ประโยชน์จาก runpath สังเกตและความแตกต่างไม่ว่าจะทำให้ ndash David Thornley ธันวาคม 3 09 เวลา 21:50 Hardy yes CPU สามารถทำสาขา ทำนายโดยไม่คำนึงถึงภาษา แต่ไม่สามารถคิดออกวงทั้งหมดได้โดยการสังเกตว่าลูปไม่มีผลต่อสิ่งใดเลย นอกจากนี้ยังจะไม่สังเกตว่า mult (0) เป็นแบบมีสายที่จะส่งกลับ 0 และแทนที่การเรียกเมธอดทั้งหมดด้วย if (param 0) result0 และหลีกเลี่ยงการเรียกฟังก์ชันเมธอดทั้งหมด C สามารถทำสิ่งเหล่านี้ได้หากคอมไพเลอร์มีภาพรวมที่ครอบคลุมเกี่ยวกับสิ่งที่เกิดขึ้น แต่โดยทั่วไปมันไม่มีข้อมูลเพียงพอในการรวบรวมข้อมูล ndash Bill K Sep 8 10 at 17:26 JIT (Just In Time Compiling) สามารถทำได้อย่างไม่น่าเชื่ออย่างรวดเร็วเนื่องจากมีการเพิ่มประสิทธิภาพสำหรับแพลตฟอร์มเป้าหมาย ซึ่งหมายความว่าสามารถใช้ประโยชน์จากเคล็ดลับของคอมไพเลอร์ที่ CPU ของคุณสามารถรองรับได้โดยไม่คำนึงว่า CPU จะเขียนโค้ดไว้ที่ใด แนวคิดพื้นฐานของ JIT ทำงานอย่างนี้ (เรียกง่าย): การเรียกใช้เมธอดเป็นครั้งแรก: รหัสโปรแกรมของคุณเรียกใช้เมธอด Foo () CLR จะดูที่ประเภทที่ใช้ Foo () และรับข้อมูลเมตาที่เกี่ยวข้อง metadata, CLR รู้ว่าหน่วยความจำที่อยู่ IL (รหัสระดับกลาง) ถูกเก็บไว้ CLR จัดสรรบล็อกของหน่วยความจำและเรียก JIT JIT จะรวบรวม IL ลงในโค้ดเนมที่วางไว้ในหน่วยความจำที่ปันส่วนแล้วเปลี่ยนตัวชี้ฟังก์ชันในข้อมูลเมตาประเภท Foo () เพื่อชี้ไปที่โค้ดเนมนี้ รหัสพื้นเมืองกำลังทำงาน เรียกใช้เมธอดเป็นครั้งที่สอง: รหัสโปรแกรมของคุณเรียกใช้เมธอด Foo () CLR มองไปที่ประเภทที่ใช้ Foo () และพบตัวชี้ฟังก์ชันในข้อมูลเมตา รหัสพื้นเมืองที่ตำแหน่งหน่วยความจำนี้ถูกเรียกใช้ อย่างที่คุณเห็นเป็นครั้งที่ 2 เกือบจะเป็นกระบวนการเดียวกับ C ยกเว้นข้อดีของการเพิ่มประสิทธิภาพแบบเรียลไทม์ ที่กล่าวว่ายังคงมีปัญหาค่าใช้จ่ายอื่น ๆ ที่ช้าลงภาษาที่มีการจัดการ แต่ JIT ช่วยได้มาก ดีก็ขึ้นอยู่กับความคิดที่ว่าเพิ่มประสิทธิภาพของคอมไพเลอร์ตามกฎและ coders don39t ดังนั้นมีเสมอไปเป็นรหัสที่เพิ่มประสิทธิภาพพบว่ามันสามารถเพิ่มประสิทธิภาพได้อย่างสมบูรณ์แบบในขณะที่มนุษย์ได้โดยการมองภาพใหญ่หรือรู้เพิ่มเติมเกี่ยวกับสิ่งที่รหัสจริงๆจะทำ ฉันจะเพิ่มว่านี่เป็นข้อคิดเห็น 3 ปีเก่าและฉันรู้เพิ่มเติมเกี่ยวกับ HotSpot กว่าที่ฉันเคยและฉันสามารถเห็นการเพิ่มประสิทธิภาพแบบไดนามิกเป็นวิธีที่ดีมากที่จะได้รับรหัสทำงานได้เร็วขึ้น ndash billjamesdev Jul 14 11 at 6:03 1. การเพิ่มประสิทธิภาพจาก Hotspot หรือ JIT อื่น ๆ ยังเป็นการเพิ่มประสิทธิภาพคอมไพเลอร์ JIT มีข้อได้เปรียบเหนือคอมไพเลอร์แบบคงที่ในการที่จะสามารถสรุปผลบางอย่าง (โค้ดที่เรียกบ่อยๆ) หรือแม้กระทั่งเพื่อทำให้การเพิ่มประสิทธิภาพขึ้นอยู่กับโปรเซสเซอร์ที่ประมวลผล แต่ก็ยังเป็นการเพิ่มประสิทธิภาพคอมไพเลอร์ 2 ฉันเดาคุณกำลังพูดถึงการเพิ่มประสิทธิภาพของขั้นตอนวิธีไม่ปรับแต่ง quoting ปรับ quotot การปรับแต่ง quotmanual assembly โดย coderquot ของมนุษย์ล้มเหลวในการสร้างผลลัพธ์ที่ดีกว่าการเพิ่มประสิทธิภาพของคอมไพเลอร์ตั้งแต่กว่าทศวรรษที่ผ่านมา ในความเป็นจริงมนุษย์เล่นกับแอสเซมบลีมักขจัดข้อสรุปใด ๆ ออกไป ndash paercebal Jul 14 11 at 16:46 Ok ฉันได้รับที่ I'm ใช้คำศัพท์ผิด, เพิ่มประสิทธิภาพ quotcompiler แทนที่จะ quotstatic optimizationquot. ฉันจะชี้ให้เห็นว่าอย่างน้อยในอุตสาหกรรมเกมเมื่อเร็ว ๆ นี้สำหรับ PS2 เรายังคงใช้การชุมนุมมือเขียนในสถานที่ quotoptimizequot สำหรับชิปเฉพาะที่เรารู้ว่าอยู่บนคอนโซลข้ามคอมไพเลอร์สำหรับชิปใหม่เหล่านี้ไม่ได้ ยังเป็นที่ซับซ้อนเช่นเดียวกับสถาปัตยกรรม x86 กลับไปที่คำถามเดิมข้างต้น: JIT มีประโยชน์ในการวัดผลก่อนการปรับให้เหมาะสมซึ่งเป็น Good Thing (TM) ndash Bill Jul 14 11 at 17:53 คุณควรกำหนดประสิทธิภาพดีกว่า ... ดีฉัน รู้คุณถามเกี่ยวกับความเร็ว แต่ไม่ใช่ทุกอย่างที่นับ เครื่องเสมือนทำค่าใช้จ่ายในการรันไทม์ได้มากขึ้นใช่ไหมพวกเขากินหน่วยความจำที่ทำงานได้มากขึ้นใช่ไหมพวกเขามีค่าใช้จ่ายในการเริ่มต้นที่สูงขึ้น (การเตรียมใช้งานรันไทม์และคอมไพเลอร์ JIT) หรือไม่ ใช่พวกเขาต้องมีไลบรารีขนาดใหญ่ที่ติดตั้งไว้ใช่และมีความลำเอียงใช่) ด้วย C และ Java คุณต้องเสียค่าใช้จ่ายสำหรับสิ่งที่คุณได้รับ (การเขียนโค้ดเร็วขึ้นการจัดการหน่วยความจำอัตโนมัติห้องสมุดขนาดใหญ่และอื่น ๆ ) แต่คุณไม่มีที่ว่างพอที่จะต่อรองรายละเอียดได้: ใช้แพคเกจที่สมบูรณ์หรือไม่มีอะไร แม้ว่าภาษาเหล่านี้จะสามารถเพิ่มประสิทธิภาพโค้ดบางส่วนให้ทำงานได้เร็วกว่าโค้ดที่คอมไพล์แล้ว แต่วิธีทั้งหมดก็คือ (IMHO) ที่ไม่มีประสิทธิภาพ ลองจินตนาการถึงการขับรถทุกวัน 5 ไมล์ไปยังที่ทำงานของคุณด้วยรถบรรทุกความสะดวกสบายรู้สึกดีคุณมีความปลอดภัย (เขตร่วนมาก) และหลังจากที่คุณเหยียบแก๊สไปสักระยะหนึ่งก็จะยิ่งเร็วเท่ารถมาตรฐานเท่านั้น dont เราทุกคนมีรถบรรทุกที่จะขับรถไปทำงาน) ใน C คุณได้รับสิ่งที่คุณจ่ายไม่มากไม่น้อย คำคม Bjarne Stroustrup: C เป็นภาษาเก็บขยะที่ฉันชอบเพราะสร้างข้อความเชื่อมโยงขยะเล็ก ๆ น้อย ๆ Stroustrup ไม่เห็นบางส่วนของโค้ดที่ฉันมี ndash kyoryu Dec 4 09 at 3:29 ดีฉันคิดว่าเขามีความคิดที่ดีของข้อเสียของเขาเขายังกล่าวว่า quotC ทำให้ง่ายต่อการยิงตัวเองในการเดินเท้า C ทำให้มันยากขึ้น แต่เมื่อคุณทำมันพัดขาทั้งหมดของคุณ offquot) ndash Frunsi Dec 4 09 at 11:24 quot ใน C คุณได้รับสิ่งที่คุณจ่ายไม่มากไม่ lessquot ตัวอย่าง: ฉันทำเกณฑ์มาตรฐานการใช้ต้นไม้ RB ใน OCaml และ C (GNU GCC) ที่ใช้ยกเว้นเพื่อกระโดดไกลออกจากการเรียกซ้ำหากมีการเพิ่มองค์ประกอบที่มีอยู่แล้วเพื่อนำชุดที่มีอยู่มาใช้ซ้ำ OCaml ได้เร็วกว่า C ถึง 6 เท่าเนื่องจากไม่ต้องจ่ายค่าตรวจสอบ destructors เมื่อ stack เป็น unwound จอน: แต่ในบางจุด (ต่อมา) ในเวลาที่มันมีการทำลายวัตถุต่อไป (อย่างน้อยก็ต้องปล่อยหน่วยความจำของ). และโปรดทราบว่าข้อยกเว้นดังกล่าวสำหรับกรณีพิเศษอย่างน้อยในกฎ C ควรได้รับการเคารพ ข้อยกเว้น C อาจจะหนักเมื่อมีข้อยกเว้นเกิดขึ้นนั่นคือการตัดจำหน่าย ndash Frunsi Sep 6 11 at 19:19 บางคำตอบที่ดีที่นี่เกี่ยวกับคำถามเฉพาะที่คุณถาม ลองย้อนกลับไปดูภาพใหญ่ ๆ โปรดจำไว้ว่าการรับรู้ความเร็วของซอฟต์แวร์ที่คุณเขียนมีผลกระทบจากปัจจัยอื่น ๆ มากกว่าการเพิ่มประสิทธิภาพ codegen นี่คือตัวอย่างบางส่วน: การจัดการหน่วยความจำด้วยตนเองทำได้ยาก (ไม่มีการรั่วไหล) และยากที่จะทำอย่างมีประสิทธิภาพ (หน่วยความจำฟรีหลังจากที่คุณเสร็จสิ้นแล้ว) การใช้ GC โดยทั่วไปมีแนวโน้มที่จะผลิตโปรแกรมที่จัดการหน่วยความจำได้ดี Are you willing to work very hard, and delay delivering your software, in an attempt to out-do the GC My C is easier to read amp understand than my C. I also have more ways to convince myself that my C code is working correctly. That means I can optimize my algorithms with less risk of introducing bugs (and users dont like software that crashes, even if it does it quickly) I can create my software faster in C than in C. That frees up time to work on performance, and still deliver my software on time. Its easier to write good UI in C than C, so Im more likely to be able to push work to the background while UI stays responsive, or to provide progress or hearbeat UI when the program has to block for a while. This doesnt make anything faster, but it makes users happier about waiting. Everything I said about C is probably true for Java, I just dont have the experience to say for sure. The virtual machine languages are unlikely to outperform compiled languages but they can get close enough that it doesnt matter, for (at least) the following reasons (Im speaking for Java here since Ive never done C). 1 The Java Runtime Environment is usually able to detect pieces of code that are run frequently and perform just-in-time (JIT) compilation of those sections so that, in future, they run at the full compiled speed. 2 Vast portions of the Java libraries are compiled so that, when you call a library function, youre executing compiled code, not interpreted. You can see the code (in C) by downloading the OpenJDK. 3 Unless youre doing massive calculations, much of the time your program is running, its waiting for input from a very slow (relatively speaking) human. 4 Since a lot of the validation of Java bytecode is done at the time of loading the class, the normal overhead of runtime checks is greatly reduced. 5 At the worst case, performance-intensive code can be extracted to a compiled module and called from Java (see JNI) so that it runs at full speed. In summary, the Java bytecode will never outperform native machine language, but there are ways to mitigate this. The big advantage of Java (as I see it) is the HUGE standard library and the cross-platform nature. Re item 2, quot2 Vast portions of the Java libraries are compiled so that, when you call a library function, you39re executing compiled code, not interpretedquot: Do you have a citation for that If it were really as you describe, I39d expect to run into native code from my debugger a lot, but I don39t. ndash cero Sep 28 08 at 22:46 Re: cero Debuggers often utilize less efficient but more expressive paths, and are therefore not a good marker for anything performance related. ndash Guvante Oct 7 08 at 18:35 Orion Adrian. let me invert your post to see how unfounded your remarks are, because a lot can be said about C as well. And telling that JavaC compiler optimize away empty functions does really make you sound like you are not my expert in optimization, because a) why should a real program contain empty functions, except for really bad legacy code, b) that is really not black and bleeding edge optimization. Apart from that phrase, you ranted blatantly about pointers, but dont objects in Java and C basically work like C pointers May they not overlap May they not be null C (and most C implementations) has the restrict keyword, both have value types, C has reference-to-value with non-null guarantee. What do Java and C offer Generally, C and C can be just as fast or faster because the AOT compiler -- a compiler that compiles your code before deployment, once and for all, on your high memory many core build server -- can make optimizations that a C compiled program cannot because it has a ton of time to do so. The compiler can determine if the machine is Intel or AMD Pentium 4, Core Solo, or Core Duo or if supports SSE4, etc, and if your compiler does not support runtime dispatch, you can solve for that yourself by deploying a handful of specialized binaries. A C program is commonly compiled upon running it so that it runs decently well on all machines, but is not optimized as much as it could be for a single configuration (i. e. processor, instruction set, other hardware), and it must spend some time first. Features like loop fission, loop inversion, automatic vectorization, whole program optimization, template expansion, IPO, and many more, are very hard to be solved all and completely in a way that does not annoy the end user. Additionally certain language features allow the compiler in C or C to make assumptions about your code that allows it to optimize certain parts away that just arent safe for the JavaC compiler to do. When you dont have access to the full type id of generics or a guaranteed program flow theres a lot of optimizations that just arent safe. Also C and C do many stack allocations at once with just one register incrementation, which surely is more efficient than Javas and C allocations as for the layer of abstraction between the garbage collector and your code. Now I cant speak for Java on this next point, but I know that C compilers for example will actually remove methods and method calls when it knows the body of the method is empty, it will eliminate common subexpressions, it may try and retry to find optimal register usage, it does not enforce bounds checking, it will autovectorize loops and inner loops and will invert inner to outer, it moves conditionals out of loops, it splits and unsplits loops. It will expand std::vector into native zero overhead arrays as youd do the C way. It will do inter procedural optimmizations. It will construct return values directly at the caller site. It will fold and propagate expressions. It will reorder data into a cache friendly manner. It will do jump threading. It lets you write compile time ray tracers with zero runtime overhead. It will make very expensive graph based optimizations. It will do strength reduction, were it replaces certain codes with syntactically totally unequal but semantically equivalent code (the old xor foo, foo is just the simplest, though outdated optimization of such kind). If you kindly ask it, you may omit IEEE floating point standards and enable even more optimizations like floating point operand re-ordering. After it has massaged and massacred your code, it might repeat the whole process, because often, certain optimizations lay the foundation for even certainer optimizations. It might also just retry with shuffled parameters and see how the other variant scores in its internal ranking. And it will use this kind of logic throughout your code. So as you can see, there are lots of reasons why certain C or C implementations will be faster. Now this all said, many optimizations can be made in C that will blow away anything that you could do with C, especially in the number crunching, realtime and close-to-metal realm, but not exclusively there. You dont even have to touch a single pointer to come a long way. So depending on what youre writing I would go with one or the other. But if youre writing something that isnt hardware dependent (driver, video game, etc), I wouldnt worry about the performance of C (again cant speak about Java). Itll do just fine. ltltltltltltltltltlt Generally, certain generalized arguments might sound cool in specific posts, but dont generally sound certainly credible. Anyways, to make peace: AOT is great, as is JIT . The only correct answer can be: It depends. And the real smart people know that you can use the best of both worlds anyways. In some cases, managed code can actually be faster than native code. For instance, mark-and-sweep garbage collection algorithms allow environments like the JRE or CLR to free large numbers of short-lived (usually) objects in a single pass, where most CC heap objects are freed one-at-a-time. For many practical purposes, allocationdeallocation-intensive algorithms implemented in garbage collected languages can actually be faster than their equivalents using manual heap allocation. A major reason for this is that the garbage collector allows the runtime system to amortize allocation and deallocation operations in a potentially advantageous fashion. That said, Ive written a lot of C and a lot of C, and Ive run a lot of benchmarks. In my experience, C is a lot faster than C, in two ways: (1) if you take some code that youve written in C, port it to C the native code tends to be faster. How much faster Well, it varies a whole lot, but its not uncommon to see a 100 speed improvement. (2) In some cases, garbage collection can massively slow down a managed application. The CLR does a terrible job with large heaps (say, 2GB), and can end up spending a lot of time in GC--even in applications that have few--or even no--objects of intermediate life spans. Of course, in most cases that Ive encounted, managed languages are fast enough, by a long shot, and the maintenance and coding tradeoff for the extra performance of C is simply not a good one. Of course, the question is whether we39re comparing an implementation of a program in managed vs. unmanaged code, or the theoretical top performance of the language. Clearly, unmanaged code can always be at least as fast as managed, as in the worst case you could just write an unmanaged program that did exactly the same thing as the managed code But most performance issues are algorithmic, not micro. Also, you don39t optimize managed and unmanaged code the same way, so quotC in Cquot is usually going to not work well. ndash kyoryu Dec 4 09 at 3:27 In CC you can allocate short lived objects on the stack, and you do when its appropriate. In managed code you cannot . you have no choice. Also, in CC you can allocate lists of objects in contigous areas (new Foo100), in managed code you cannot. So, your comparison is not valid. Well, this power of choices places a burden on the developers, but this way they learn to know the world they live in (memory. ). ndash Frunsi Dec 6 09 at 3:39 Go read about HP Labs Dynamo. an interpreter for PA-8000 that runs on PA-8000, and often runs programs faster than they do natively. Then it wont seem at all surprising Dont think of it as an intermediate step -- running a program involves lots of other steps already, in any language. It often comes down to: programs have hot-spots, so even if youre slower running 95 of the body of code you have to run, you can still be performance-competitive if youre faster at the hot 5 a HLL knows more about your intent than a LLL like CC, and so can generate more optimized code (OCaml has even more, and in practice is often even faster) a JIT compiler has a lot of information that a static compiler doesnt (like, the actual data you happen to have this time) a JIT compiler can do optimizations at run-time that traditional linkers arent really allowed to do (like reordering branches so the common case is flat, or inlining library calls) All in all, CC are pretty lousy languages for performance: theres relatively little information about your data types, no information about your data, and no dynamic runtime to allow much in the way of run-time optimization. My understanding is that CC produces native code to run on a particular machine architecture. Conversely, languages like Java and C run on top of a virtual machine which abstracts away the native architecture. Logically it would seem impossible for Java or C to match the speed of C because of this intermediate step, however Ive been told that the latest compilers (hot spot) can attain this speed or even exceed it. That is illogical. The use of an intermediate representation does not inherently degrade performance. For example, llvm-gcc compiles C and C via LLVM IR (which is a virtual infinite-register machine) to native code and it achieves excellent performance (often beating GCC). Perhaps this is more of a compiler question than a language question, but can anyone explain in plain English how it is possible for one of these virtual machine languages to perform better than a native language Here are some examples: Virtual machines with JIT compilation facilitate run-time code generation (e. g. System. Reflection. Emit on ) so you can compile generated code on-the-fly in languages like C and F but must resort to writing a comparatively-slow interpreter in C or C. For example, to implement regular expressions. Parts of the virtual machine (e. g. the write barrier and allocator) are often written in hand-coded assembler because C and C do not generate fast enough code. If a program stresses these parts of a system then it could conceivably outperform anything that can be written in C or C. Dynamic linking of native code requires conformance to an ABI that can impede performance and obviates whole-program optimization whereas linking is typically deferred on VMs and can benefit from whole-program optimizations (like s reified generics). Id also like to address some issues with paercebals highly-upvoted answer above (because someone keeps deleting my comments on his answer) that presents a counter-productively polarized view: The code processing will be done at compilation time. Hence template metaprogramming only works if the program is available at compile time which is often not the case, e. g. it is impossible to write a competitively performant regular expression library in vanilla C because it is incapable of run-time code generation (an important aspect of metaprogramming). playing with types is done at compile time. the equivalent in Java or C is painful at best to write, and will always be slower and resolved at runtime even when the types are known at compile time. In C, that is only true of reference types and is not true for value types. No matter the JIT optimization, nothing will go has fast as direct pointer access to memory. if you have contiguous data in memory, accessing it through C pointers (i. e. C pointers. Lets give Caesar its due) will goes times faster than in JavaC. People have observed Java beating C on the SOR test from the SciMark2 benchmark precisely because pointers impede aliasing-related optimizations. Also worth noting that does type specialization of generics across dynamically-linked libraries after linking whereas C cannot because templates must be resolved before linking. And obviously the big advantage generics have over templates is comprehensible error messages. C Fundamentals for Borland C Builder 2012-05-14 04:31:36 By Console77 Version: C Fundamentals for Borland C Builder 6.0 Easy for beginners, else none - No reliable internet components - Simple graphics, unless you dare rely on thirds party VCLs - No 64bit support - Buggy - Thirdparty VCLs are also buggy - Not a standard product - Less and less vendors supports DelphiC Builder - Insecure future, a sinking ship Embarcadero and their products are a sinking ship, together with the third party tools. There are always problems, bugs, or simply a connectivity is not supported. You never know if it is You, the third part VCL vendor or Emarcadero creating the problems. We have used an obsene amount of time in error finding, debugging. There is still no support for 64bit in C Builder, and the datasnap is unreliable, new releases are always buggy. Emrabadero has no reliable internet connectivity, but rely on Indy, which is unreliable and very difficult to manage. We now face more and more that we need to add plug-ins to our application, but they are not supporting Delphi C Builder. So, we now have to migrate to the standard, which is Visual Studio 2010. Perhaps for hobby projects DelphiC Builder is ok - but not for commercial applications. 34I use before old version34