ควรใช้ฟังก์ชั่นอินไลน์เมื่อใดและจะไม่ใช้เมื่อใด

ฉันรู้ว่าอินไลน์เป็นคำใบ้หรือคำขอให้คอมไพเลอร์และมันใช้เพื่อหลีกเลี่ยงค่าใช้จ่ายในการโทรฟังก์ชั่น

ดังนั้นสิ่งที่พื้นฐานหนึ่งสามารถกำหนดได้ว่าฟังก์ชั่นเป็นตัวเลือกสำหรับการอินไลน์หรือไม่? ในกรณีใดที่หนึ่งควรหลีกเลี่ยงการอินไลน์

การหลีกเลี่ยงค่าใช้จ่ายในการเรียกใช้ฟังก์ชันเป็นเพียงครึ่งเดียวของเรื่องราว

ทำ:

• ใช้inlineแทน#define
• ฟังก์ชั่นที่เล็กมากเป็นตัวเลือกที่ดีสำหรับinline: โค้ดที่เร็วขึ้นและ executables เล็ก (โอกาสที่จะอยู่ในแคชของโค้ด)
• ฟังก์ชั่นมีขนาดเล็กและเรียกบ่อยมาก

ไม่ได้:

• ฟังก์ชั่นขนาดใหญ่: นำไปสู่การปฏิบัติการที่มีขนาดใหญ่ขึ้นซึ่งจะบั่นทอนประสิทธิภาพการทำงานอย่างมาก
• ฟังก์ชันแบบอินไลน์ที่ถูกผูกไว้ I / O
• ฟังก์ชั่นนี้ไม่ค่อยได้ใช้
• คอนสตรัคเตอร์และ destructors: แม้จะว่างเปล่าคอมไพเลอร์สร้างรหัสสำหรับพวกเขา
• ทำลายความเข้ากันได้ไบนารีเมื่อพัฒนาห้องสมุด:
  • อินไลน์ฟังก์ชั่นที่มีอยู่
  • เปลี่ยนฟังก์ชั่นแบบอินไลน์หรือทำให้ฟังก์ชั่นแบบอินไลน์ที่ไม่ใช่แบบอินไลน์: รุ่นก่อนหน้าของห้องสมุดเรียกการใช้งานเก่า

เมื่อพัฒนาห้องสมุดเพื่อที่จะทำให้ชั้นเรียนขยายได้ในอนาคตคุณควร:

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

โปรดจำไว้ว่าinlineคำหลักนั้นเป็นคำใบ้ของคอมไพเลอร์: คอมไพเลอร์อาจตัดสินใจที่จะไม่อินไลน์ฟังก์ชั่นและมันสามารถตัดสินใจที่จะอินไลน์ฟังก์ชั่นที่ไม่ได้ทำเครื่องหมายinlineในสถานที่แรก ฉันมักจะหลีกเลี่ยงการทำเครื่องหมายฟังก์ชั่นinline(นอกเหนือจากบางทีเมื่อเขียนฟังก์ชั่นที่เล็กมาก ๆ )

เกี่ยวกับประสิทธิภาพวิธีการที่ชาญฉลาดคือ (เช่นเคย) เพื่อทำโปรไฟล์แอปพลิเคชันจากนั้นinlineชุดของฟังก์ชันที่แสดงถึงคอขวดในที่สุด

อ้างอิง:

• เป็นแบบอินไลน์หรือไม่เป็นแบบอินไลน์
• [9] ฟังก์ชั่นอินไลน์
• นโยบาย / ปัญหาความเข้ากันได้ของไบนารีด้วย C ++
• GotW # 33: อินไลน์
• Inline Redux
• Effective C ++ - Item 33: ใช้การอินไลน์อย่างรอบคอบ

แก้ไข: Bjarne Stroustrup, ภาษา C ++ การเขียนโปรแกรม:

inlineฟังก์ชั่นที่สามารถกำหนดให้เป็น ตัวอย่างเช่น:

inline int fac(int n)
{
  return (n < 2) ? 1 : n * fac(n-1);
}

ตัวinlineระบุเป็นคำใบ้ของคอมไพเลอร์ที่ควรพยายามสร้างรหัสสำหรับการโทรfac()แบบอินไลน์แทนที่จะวางโค้ดสำหรับฟังก์ชั่นหนึ่งครั้งแล้วเรียกผ่านกลไกการเรียกฟังก์ชันตามปกติ เรียบเรียงฉลาดสามารถสร้างอย่างต่อเนื่องสำหรับการโทร720 fac(6)ความเป็นไปได้ของฟังก์ชั่นอินไลน์แบบเรียกซ้ำร่วมกันฟังก์ชั่นอินไลน์ที่ชดเชยหรือไม่ขึ้นอยู่กับอินพุต ฯลฯ ทำให้ไม่สามารถรับประกันได้ว่าการเรียกใช้inlineฟังก์ชันทุกครั้งจะถูกขีดเส้นใต้ ระดับของความฉลาดของคอมไพเลอร์ไม่สามารถออกกฏหมายดังนั้นหนึ่งคอมไพเลอร์อาจสร้าง720อีกและอีกสายเรียกยกเลิก6 * fac(5) inlinedfac(6)

เพื่อให้การอินไลน์เป็นไปได้หากไม่มีการรวบรวมและเชื่อมโยงสิ่งอำนวยความสะดวกที่ฉลาดผิดปกติคำจำกัดความ - และไม่ใช่แค่การประกาศ - ของฟังก์ชันอินไลน์ต้องอยู่ในขอบเขต (§9.2) ตัวระบุinlineไม่มีผลต่อความหมายของฟังก์ชัน โดยเฉพาะอย่างยิ่งฟังก์ชั่นแบบอินไลน์ยังคงมีที่อยู่ที่ไม่ซ้ำกันและมีstaticตัวแปร (§7.1.2) ของฟังก์ชั่นอินไลน์

EDIT2: ISO-IEC 14882-1998, 7.1.2 ตัวระบุฟังก์ชั่น

การประกาศฟังก์ชัน (8.3.5, 9.3, 11.4) พร้อมตัวinlineระบุประกาศฟังก์ชันอินไลน์ ตัวระบุอินไลน์บ่งชี้ถึงการใช้งานที่การทดแทนแบบอินไลน์ของร่างกายของฟังก์ชั่นที่จุดของการโทรจะเป็นที่ต้องการกับกลไกการเรียกใช้ฟังก์ชั่นปกติ การดำเนินการไม่จำเป็นต้องดำเนินการทดแทนแบบอินไลน์นี้ ณ จุดที่เรียก; อย่างไรก็ตามแม้ว่าจะมีการละเว้นการแทนที่แบบอินไลน์นี้กฎอื่น ๆ สำหรับฟังก์ชั่นแบบอินไลน์ที่กำหนดโดย 7.1.2 จะยังคงได้รับการเคารพ

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

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

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

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

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

คุณอาจประหลาดใจแม้ว่า - คอมไพเลอร์ C ++ หลายคนจะอินไลน์ฟังก์ชั่นเล็ก ๆ ให้คุณโดยอัตโนมัติและพวกเขาอาจเพิกเฉยต่อคำขออินไลน์ของคุณเช่นกัน

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

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

การเพิ่มประสิทธิภาพก่อนวัยอันควรเป็นรากฐานของความชั่วร้ายทั้งหมด!

ตามกฎของหัวแม่มือฉันมักจะแทรก "getters" และ "setters" เท่านั้น เมื่อโค้ดทำงานและมีความเสถียรการทำโปรไฟล์สามารถแสดงว่าฟังก์ชันใดที่จะได้ประโยชน์จากการอินไลน์

ในทางกลับกันคอมไพเลอร์สมัยใหม่ส่วนใหญ่มีอัลกอริธึมการปรับให้เหมาะสมค่อนข้างดี

Reasuming - เขียนฟังก์ชั่นหนึ่งซับในบรรทัดและกังวลเกี่ยวกับผู้อื่นในภายหลัง

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

คุณสามารถอ่านเพิ่มเติมเกี่ยวกับอินไลน์ในc ++ faq

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

void IncreaseCount() { freeInstancesCnt++; }

ผู้อ่านรู้ได้ทันทีถึงความหมายที่สมบูรณ์ของรหัส

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

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

เมื่อตัดสินใจว่าจะใช้แบบอินไลน์ฉันมักจะคำนึงถึงความคิดต่อไปนี้: ในการแฝงหน่วยความจำของเครื่องที่ทันสมัยอาจเป็นคอขวดที่ใหญ่กว่าการคำนวณแบบดิบ ฟังก์ชั่นอินไลน์ที่เรียกว่ามักจะเป็นที่รู้จักกันในการขยายขนาดที่ปฏิบัติการ นอกจากนี้ฟังก์ชั่นดังกล่าวสามารถเก็บไว้ในแคชรหัสของ CPU ซึ่งจะลดจำนวนของแคชที่หายไปเมื่อจำเป็นต้องเข้าถึงรหัสนั้น

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

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

• รูทีนแบบสั้นที่เรียกว่าในการวนรอบแบบแน่น
• accessors พื้นฐานมาก (รับ / ชุด) และฟังก์ชั่น wrapper
• รหัสเทมเพลตในไฟล์ส่วนหัวน่าเสียดายที่ได้รับคำแนะนำแบบอินไลน์โดยอัตโนมัติ
• รหัสย่อที่ใช้เหมือนแมโคร (เช่นนาที () / สูงสุด ())
• กิจวัตรคณิตศาสตร์สั้น ๆ

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

เมื่อinlineวิธีการถูกถ่ายโอนไปยังไฟล์ต้นฉบับและไม่ได้ inlined อีกโครงการทั้งหมดจะต้องสร้างใหม่ (อย่างน้อยก็เป็นประสบการณ์ของฉัน) และเมื่อมีการแปลงวิธีการเป็นแบบอินไลน์

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

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

ฉันอ่านคำตอบแล้วเห็นว่ามีบางอย่างขาดหายไป

กฎที่ฉันใช้คือไม่ใช้อินไลน์ยกเว้นว่าฉันต้องการให้เป็นแบบอินไลน์ ดูเหมือนโง่ตอนนี้คำอธิบาย

คอมไพเลอร์ฉลาดพอและฟังก์ชั่นระยะสั้นทำให้อินไลน์เสมอ และไม่ทำให้ฟังก์ชั่นแบบยาวเป็นแบบอินไลน์เว้นแต่โปรแกรมเมอร์จะทำเช่นนั้น

ฉันรู้ว่าอินไลน์เป็นคำใบ้หรือคำขอให้คอมไพเลอร์

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

ดังนั้นควรใช้เมื่อinlineใด

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

เช่นฉันมีฟังก์ชั่นนี้:

inline bool ValidUser(const std::string& username, const std::string& password)
{
    //here it is quite long function
}

ไม่ว่าฟังก์ชั่นนี้จะใหญ่แค่ไหนก็ตามเพราะมันทำให้ซอฟต์แวร์แตกได้ยากขึ้น