มันเป็นการปฏิบัติที่ไม่ถูกต้องหรือไม่ในการเขียนโค้ดที่ต้องอาศัยการปรับให้เหมาะสมของคอมไพเลอร์?

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

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

นี่เป็นการเพิ่มประสิทธิภาพขนาดเล็กหรือสิ่งที่ฉันควรทราบเมื่อออกแบบรหัสของฉัน

ใช้หลักการที่น่าประหลาดใจน้อยที่สุด

เป็นคุณและคนที่เคยใช้รหัสนี้และคุณแน่ใจหรือไม่ว่าคุณใน 3 ปีนั้นจะไม่ประหลาดใจกับสิ่งที่คุณทำ?

จากนั้นไปข้างหน้า

ในกรณีอื่น ๆ ให้ใช้วิธีมาตรฐาน ไม่เช่นนั้นคุณและเพื่อนร่วมงานของคุณจะพบเจอข้อบกพร่องอย่างหนัก

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

สำหรับกรณีนี้โดยเฉพาะเพียงแค่คืนค่า

• RVO และ NRVO เป็นที่รู้จักกันดีและมีการปรับแต่งที่เหมาะสมซึ่งควรทำโดยผู้รวบรวมที่เหมาะสมแม้ในโหมด C ++ 03

• ซีแมนทิกส์ย้ายทำให้แน่ใจว่าวัตถุถูกย้ายออกจากฟังก์ชั่นหาก (N) RVO ไม่เกิดขึ้น ที่มีประโยชน์เฉพาะในกรณีที่วัตถุของคุณใช้ข้อมูลแบบไดนามิกภายใน (เช่นstd::vectorไม่) แต่ที่จริงควรจะเป็นกรณีที่ถ้ามันเป็นที่ใหญ่ - ล้นสแต็คคือความเสี่ยงกับวัตถุอัตโนมัติขนาดใหญ่

• C ++ 17 บังคับใช้ RVO ดังนั้นไม่ต้องกังวลมันจะไม่หายไปกับคุณและจะเสร็จสิ้นการสร้างตัวเองอย่างสมบูรณ์เมื่อคอมไพเลอร์เป็นรุ่นล่าสุด

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

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

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

นี่ไม่ใช่การเพิ่มประสิทธิภาพขนาดเล็กที่รู้จักกันน่ารู้และเล็ก ๆ น้อย ๆ ที่คุณได้อ่านในบล็อกเล็ก ๆ

หลังจาก C ++ 11, RVO เป็นวิธีมาตรฐานในการเขียนรหัสของรหัสนี้ เป็นเรื่องปกติที่คาดว่าจะได้รับการสอนในการพูดถึงพูดถึงในบล็อกที่กล่าวถึงในมาตรฐานจะถูกรายงานว่าเป็นข้อผิดพลาดคอมไพเลอร์หากไม่ได้ใช้งาน ใน C ++ 17 ภาษาจะดำเนินต่อไปอีกขั้นหนึ่งแล้วสั่งการคัดลอกการคัดออกในบางสถานการณ์

คุณควรพึ่งพาการเพิ่มประสิทธิภาพนี้อย่างแน่นอน

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

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

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

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

ฉันคิดว่าตัวอย่างที่ดีที่สุดในเรื่องนี้ในทางปฏิบัติของฉันคือการปรับให้เหมาะสมหาง:

   int sillyAdd(int a, int b)
   {
      if (b == 0)
          return a;
      return sillyAdd(a + 1, b - 1);
   }

มันเป็นตัวอย่างที่งี่เง่า แต่มันแสดงให้เห็นถึงการเรียกแบบหางโดยที่ฟังก์ชั่นนั้นถูกเรียกซ้ำในตอนท้ายของฟังก์ชั่น เครื่องเสมือน C ++ จะแสดงให้เห็นว่ารหัสนี้ทำงานอย่างถูกต้องแม้ว่าฉันอาจทำให้เกิดความสับสนเล็กน้อยว่าทำไมฉันจึงต้องใส่ใจกับการเขียนรูทีนเพิ่มเติมดังกล่าวในตอนแรก อย่างไรก็ตามในการใช้งานจริงของ C ++ เรามีสแต็กและมีพื้นที่ จำกัด หากทำไปเรื่อย ๆ ฟังก์ชันนี้จะต้องผลักb + 1เฟรมสแต็กอย่างน้อยลงในสแต็กเช่นเดียวกับที่เพิ่มเข้าไป ถ้าฉันต้องการคำนวณsillyAdd(5, 7)นี่ไม่ใช่เรื่องใหญ่ ถ้าฉันต้องการคำนวณsillyAdd(0, 1000000000)ฉันอาจมีปัญหาในการก่อให้เกิด StackOverflow (และไม่ใช่ประเภทที่ดี )

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

   int sillyAdd(int a, int b)
   {
      begin:
      if (b == 0)
          return a;
      // return sillyAdd(a + 1, b - 1);
      a = a + 1;
      b = b - 1;
      goto begin;  
   }

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

เพราะฉะนั้นมันก็จะไม่ดีสำหรับผมที่จะขึ้นอยู่กับsillyAdd(0, 1000000000)ความสามารถในการคำนวณ

ในทางปฏิบัติโปรแกรม C ++ คาดว่าจะมีการปรับแต่งคอมไพเลอร์ให้เหมาะสม

ดูสะดุดตาในส่วนหัวมาตรฐานของการใช้งานคอนเทนเนอร์มาตรฐานของคุณ ด้วยGCCคุณสามารถขอแบบฟอร์มที่ประมวลผลล่วงหน้า ( g++ -C -E) และการเป็นตัวแทนภายใน GIMPLE ( g++ -fdump-tree-gimpleหรือ Gimple SSA ด้วย-fdump-tree-ssa) ของไฟล์ต้นฉบับส่วนใหญ่ (หน่วยการแปลทางเทคนิค) โดยใช้คอนเทนเนอร์ คุณจะประหลาดใจกับจำนวนของการเพิ่มประสิทธิภาพที่ทำได้ (ด้วยg++ -O2) ดังนั้นผู้พัฒนาระบบของคอนเทนเนอร์จึงต้องพึ่งพาการปรับให้เหมาะสมที่สุด (และส่วนใหญ่แล้วผู้ดำเนินการของไลบรารีมาตรฐาน C ++ จะรู้ว่าการเพิ่มประสิทธิภาพจะเกิดอะไรขึ้นและเขียนการใช้งานคอนเทนเนอร์ด้วยผู้ที่อยู่ในใจ จัดการกับคุณสมบัติที่ต้องการโดยไลบรารีมาตรฐาน C ++ แล้ว)

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

และเช่นเดียวกันกับกรณี RVO ที่กล่าวถึงในคำถามของคุณ

มาตรฐาน C ++ ได้รับการออกแบบร่วมกัน (โดยเฉพาะอย่างยิ่งโดยการทดสอบการเพิ่มประสิทธิภาพที่ดีพอในขณะที่เสนอคุณสมบัติใหม่) เพื่อให้ทำงานได้ดีกับการปรับให้เหมาะสมที่สุด

ตัวอย่างเช่นพิจารณาโปรแกรมด้านล่าง:

#include <algorithm>
#include <vector>

extern "C" bool all_positive(const std::vector<int>& v) {
  return std::all_of(v.begin(), v.end(), [](int x){return x >0;});
}

g++ -O3 -fverbose-asm -Sรวบรวมไว้ด้วย คุณจะพบว่าฟังก์ชั่นที่สร้างขึ้นไม่ได้รันCALLคำสั่งเครื่องใด ๆ ดังนั้นขั้นตอน C ++ ส่วนใหญ่ (การสร้างการปิดแลมบ์ดา, การสมัครซ้ำ, การรับbeginและการendวนซ้ำ ฯลฯ ... ) ได้รับการปรับปรุง รหัสเครื่องมีการวนซ้ำ (ซึ่งไม่ปรากฏอย่างชัดเจนในซอร์สโค้ด) หากไม่มีการปรับให้เหมาะสม C ++ 11 จะไม่ประสบความสำเร็จ

ภาคผนวก

(เพิ่ม 31 ธันวาคม^{เซนต์} 2017)

ดูCppCon 2017: Matt Godbolt“ เมื่อไม่นานมานี้คอมไพเลอร์ของฉันทำอะไรให้ฉัน? Unbolting ฝาคอมไพเลอร์ของ”การพูดคุย

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

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

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

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

ฉันคิดว่าคนอื่นครอบคลุมมุมเฉพาะเกี่ยวกับ C ++ และ RVO ดี นี่คือคำตอบทั่วไปเพิ่มเติม:

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

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

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

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

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

การใช้ธงคอมไพเลอร์ที่เปลี่ยนวิธีการคำนวณควรมีการบันทึกไว้เป็นอย่างดี แต่ใช้ตามความจำเป็น

เลขที่

นั่นคือสิ่งที่ฉันทำตลอดเวลา หากฉันต้องการเข้าถึงบล็อกหน่วยความจำ 16 บิตโดยพลการฉันจะทำสิ่งนี้

void *ptr = get_pointer();
uint16_t u16;
memcpy(&u16, ptr, sizeof(u16)); // ntohs omitted for simplicity

... และพึ่งพาคอมไพเลอร์ที่ทำทุกอย่างเท่าที่ทำได้เพื่อเพิ่มประสิทธิภาพโค้ด รหัสนี้ใช้งานได้กับ ARM, i386, AMD64 และในทุก ๆ สถาปัตยกรรม ในทางทฤษฎีแล้วคอมไพเลอร์ที่ไม่ได้รับการออปติไมซ์สามารถเรียกได้จริงmemcpyส่งผลให้เกิดประสิทธิภาพที่ไม่ดีโดยสิ้นเชิง แต่นั่นก็ไม่มีปัญหาสำหรับฉัน

พิจารณาทางเลือก:

void *ptr = get_pointer();
uint16_t *u16ptr = ptr;
uint16_t u16;
u16 = *u16ptr;  // ntohs omitted for simplicity

รหัสทางเลือกนี้ไม่สามารถทำงานกับเครื่องที่ต้องการการจัดตำแหน่งที่เหมาะสมหากget_pointer()ส่งคืนตัวชี้ที่ไม่จัดแนว นอกจากนี้อาจมีปัญหาเรื่องนามแฝงในทางเลือก

ความแตกต่างระหว่าง -O2 และ -O0 เมื่อใช้memcpyเคล็ดลับนั้นยอดเยี่ยม: ประสิทธิภาพการตรวจสอบ IP 3.2 Gbps เทียบกับประสิทธิภาพการตรวจสอบ IP 67 Gbps ด้วยลำดับความแตกต่างที่มีขนาด!

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

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

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

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

หากเราไม่รู้สึกว่าเราสามารถพึ่งพาความสามารถของเครื่องมือเพิ่มประสิทธิภาพของเราในการเพิ่มประสิทธิภาพรหัสของเราเราทุกคนยังคงเข้ารหัสเส้นทางการปฏิบัติที่สำคัญต่อประสิทธิภาพในการประกอบ

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

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

ข้อผิดพลาดที่ด้านข้างของการใช้เครื่องมือเพิ่มประสิทธิภาพไม่กลัวมัน

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

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

โปรไฟล์

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

ซอฟต์แวร์สามารถเขียนใน C ++ บนแพลตฟอร์มที่แตกต่างกันมากและเพื่อวัตถุประสงค์ที่แตกต่างกันมากมาย

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

ฉันคิดว่าคำตอบที่น่าเบื่อคือ: 'มันขึ้นอยู่กับว่า'

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

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

หากคุณไม่ได้บอกเรามากกว่านี้ก็เป็นการฝึกฝนที่ไม่ดี แต่ไม่ใช่ด้วยเหตุผลที่คุณแนะนำ

อาจแตกต่างจากภาษาอื่น ๆ ที่คุณเคยใช้มาก่อนการคืนค่าของวัตถุใน C ++ ให้ผลลัพธ์เป็นสำเนาของวัตถุ หากคุณปรับเปลี่ยนวัตถุคุณกำลังแก้ไขวัตถุอื่น นั่นคือถ้าผมมีObj a; a.x=1;และObj b = a;ผมก็ทำb.x += 2; b.f();แล้วa.xยังคงเท่ากับ 1, 3 ไม่ได้

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

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

"สร้างวัตถุในฟังก์ชั่น" เสียงเหมือนnew Obj;ที่ "ส่งคืนวัตถุตามค่า" เสียงเหมือนObj a; return a;

Obj a;และObj* a = new Obj;แตกต่างกันมาก อดีตอาจส่งผลให้เกิดความเสียหายหน่วยความจำหากไม่ได้ใช้และเข้าใจอย่างถูกต้องและหลังอาจส่งผลให้หน่วยความจำรั่วหากไม่ได้ใช้และเข้าใจอย่างถูกต้อง

Pieter B นั้นถูกต้องอย่างยิ่งในการแนะนำสิ่งที่น่าประหลาดใจ

เพื่อตอบคำถามเฉพาะของคุณความหมาย (น่าจะเป็นไปได้มากที่สุด) ในภาษา C ++ คือคุณควรกลับstd::unique_ptrไปหาวัตถุที่สร้างขึ้น

เหตุผลก็คือสิ่งนี้ชัดเจนสำหรับนักพัฒนา C ++ว่าเกิดอะไรขึ้น

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

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