สำนวน C ++ ใดเลิกใช้ใน C ++ 11

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

วิธีการเข้ารหัสแบบเก่า ๆ นั้นด้อยกว่า C ++ 11 สไตล์แน่นอนและตอนนี้เราจะทำอะไรได้บ้าง?

ในการตอบคำถามนี้คุณอาจข้ามสิ่งที่ชัดเจนเช่น "ใช้ตัวแปรอัตโนมัติ"

1. Final Class : C ++ 11 ให้ตัวfinalระบุเพื่อป้องกันการสืบทอดคลาส
2. C ++ 11 lambdas ลดความจำเป็นในการใช้คลาสฟังก์ชั่นชื่อวัตถุ (functor)
3. Move Constructor : ไม่ต้องใช้เวทย์มนตร์ในการstd::auto_ptrทำงานอีกต่อไปเนื่องจากการสนับสนุนชั้นหนึ่งสำหรับการอ้างอิง rvalue
4. บูลที่ปลอดภัย : สิ่งนี้ถูกกล่าวถึงก่อนหน้านี้ ตัวดำเนินการอย่างชัดเจนของ C ++ 11 จะกำจัดสำนวน C ++ 03 ที่พบบ่อยมากนี้
5. ย่อขนาดให้พอดี : คอนเทนเนอร์ C ++ 11 STL จำนวนมากมีshrink_to_fit()ฟังก์ชันสมาชิกซึ่งควรกำจัดความต้องการในการแลกเปลี่ยนด้วยชั่วคราว
6. คลาสฐานชั่วคราว : ไลบรารี C ++ เก่าบางตัวใช้สำนวนที่ค่อนข้างซับซ้อน ด้วยซีแมนทิกส์ย้ายไม่จำเป็นอีกต่อไป
7. Type Enum Enumerations ปลอดภัยมากใน C ++ 11
8. การห้ามการจัดสรรฮีป : = deleteไวยากรณ์เป็นวิธีที่ตรงกว่าในการบอกว่าการทำงานเฉพาะนั้นถูกปฏิเสธอย่างชัดเจน สิ่งนี้ใช้ได้กับการป้องกันการจัดสรรฮีป (เช่น=deleteสำหรับสมาชิกoperator new) การป้องกันการคัดลอกการมอบหมาย ฯลฯ
9. เท็มเพลต Templated : เทมเพลต Aliasใน C ++ 11 ลดความต้องการเทมเพลตเท็มเพลตที่เรียบง่าย อย่างไรก็ตามเครื่องกำเนิดไฟฟ้าชนิดซับซ้อนยังคงต้องการฟังก์ชันเมตา
10. การคำนวณเวลารวบรวมแบบตัวเลขบางตัวเช่นฟีโบนักชีสามารถเปลี่ยนได้อย่างง่ายดายโดยใช้นิพจน์คงที่ทั่วไป
11. result_of: การใช้แม่แบบชั้นจะถูกแทนที่ด้วยresult_of decltypeฉันคิดว่าresult_ofใช้decltypeเมื่อมันใช้ได้
12. สมาชิกในคลาส initializersบันทึกการพิมพ์สำหรับการเริ่มต้นเริ่มต้นของสมาชิกแบบคงที่ที่มีค่าเริ่มต้น
13. ในรหัส C ++ 11 NULLใหม่ควรกำหนดใหม่เป็นnullptrแต่ดูการพูดคุยของ STLเพื่อเรียนรู้ว่าทำไมพวกเขาถึงตัดสินใจ
14. ผู้ที่ชื่นชอบเทมเพลตของนิพจน์มีความยินดีที่ได้รับไวยากรณ์ของฟังก์ชันประเภทส่งคืนใน C ++ 11 ไม่มีประเภทผลตอบแทนคืนยาว 30 บรรทัด!

ฉันคิดว่าฉันจะหยุดที่นั่น!

ในช่วงเวลาหนึ่งมันก็เป็นที่ถกเถียงกันอยู่ว่าควรจะกลับมาตามconstตัวอักษรแทนที่จะตามตัวอักษรตามตัวอักษร:

const A foo();
^^^^^

สิ่งนี้ไม่เป็นอันตรายส่วนใหญ่ใน C ++ 98/03 และอาจพบข้อบกพร่องบางอย่างที่ดูเหมือน:

foo() = a;

แต่การย้อนกลับโดยconstมีข้อห้ามใน C ++ 11 เพราะยับยั้งการย้ายความหมาย:

A a = foo();  // foo will copy into a instead of move into it

ดังนั้นเพียงแค่ผ่อนคลายและรหัส:

A foo();  // return by non-const value

เร็วที่สุดเท่าที่คุณสามารถละทิ้ง0และNULLในความโปรดปรานของnullptrทำเช่นนั้น!

ในรหัสที่ไม่ใช่แบบทั่วไปการใช้0หรือNULLไม่ได้เป็นเรื่องใหญ่ แต่ทันทีที่คุณเริ่มส่งผ่านค่าคงที่ตัวชี้โมฆะในรหัสทั่วไปสถานการณ์จะเปลี่ยนไปอย่างรวดเร็ว เมื่อคุณผ่าน0การtemplate<class T> func(T) Tรับการอนุมานเป็นintและไม่เป็นค่าคงที่ตัวชี้โมฆะ และไม่สามารถแปลงกลับเป็นค่าคงที่ตัวชี้ว่างหลังจากนั้น nullptrน้ำตกนี้ลงในหล่มปัญหาที่ก็ไม่อยู่ถ้าจักรวาลใช้เฉพาะ

C ++ 11 ไม่คัดค้าน0และNULLเป็นค่าคงที่ตัวชี้โมฆะ แต่คุณควรเขียนโค้ดราวกับว่ามันเป็น

ปลอดภัยสำนวนบูลexplicit operator bool() →

ตัวสร้างสำเนาส่วนตัว (boost :: noncopyable) → X(const X&) = delete

การจำลองคลาสสุดท้ายด้วย destructor ส่วนตัวและการสืบทอดเสมือนจริง →class X final

หนึ่งในสิ่งที่ทำให้คุณหลีกเลี่ยงการเขียนอัลกอริธึมพื้นฐานใน C ++ 11 คือความพร้อมใช้ของ lambdas เมื่อใช้ร่วมกับอัลกอริทึมที่จัดทำโดยไลบรารีมาตรฐาน

ฉันกำลังใช้สิ่งเหล่านี้ในตอนนี้และมันเหลือเชื่อว่าคุณจะบอกสิ่งที่คุณต้องการทำบ่อยเพียงใดโดยใช้ count_if (), for_each () หรืออัลกอริทึมอื่น ๆ แทนที่จะต้องเขียนลูปแช่งอีกครั้ง

เมื่อคุณใช้คอมไพเลอร์ C ++ 11 กับไลบรารี่มาตรฐาน C ++ 11 ที่สมบูรณ์คุณจะไม่มีข้อแก้ตัวที่ดีอีกต่อไปที่จะไม่ใช้อัลกอริธึมมาตรฐานเพื่อสร้างของคุณ แลมบ์ดาแค่ฆ่ามัน

ทำไม?

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

โดยทั่วไปขั้นตอนวิธีการอ่านที่สร้างด้วยอัลกอริธึมมาตรฐานนั้นง่ายกว่ามากเมื่อคำที่ซ่อนรายละเอียดการนำไปใช้ของลูป

ฉันเดาว่าอัลกอริทึมระดับสูงกว่าต้องได้รับการคิดตอนนี้ว่าเรามีอัลกอริทึมระดับต่ำกว่าที่จะสร้าง

คุณจะต้องใช้งานเวอร์ชันที่กำหนดเองswapไม่บ่อยนัก ใน C ++ 03 การโยนแบบไม่มีประสิทธิภาพswapมักจะจำเป็นเพื่อหลีกเลี่ยงค่าใช้จ่ายและการคัดลอกและเนื่องจากต้องstd::swapใช้สองสำเนาswapบ่อยครั้งจะต้องมีการปรับแต่ง ใน C ++ ให้std::swapใช้moveและเพื่อให้ความสำคัญกับการใช้งานตัวสร้างการย้ายที่มีประสิทธิภาพและไม่โยนและตัวดำเนินการกำหนดค่า เนื่องจากสำหรับค่าเริ่มต้นเหล่านี้มักจะใช้ได้ผลนี้จะทำงานน้อยกว่าใน C ++ 03

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

ฉันไม่ทราบชื่อของมัน แต่รหัส C ++ 03 มักจะใช้โครงสร้างต่อไปนี้แทนการมอบหมายการย้ายที่ขาดหายไป:

std::map<Big, Bigger> createBigMap(); // returns by value

void example ()
{
  std::map<Big, Bigger> map;

  // ... some code using map

  createBigMap().swap(map);  // cheap swap
}

สิ่งนี้หลีกเลี่ยงการทำสำเนาใด ๆ เนื่องจากการคัดลอกตัวเลือกรวมกับswapด้านบน

เมื่อฉันสังเกตเห็นว่าคอมไพเลอร์ใช้มาตรฐาน C ++ 11 ไม่ผิดพลาดรหัสต่อไปนี้:

std::vector<std::vector<int>> a;

>> ฉันเริ่มเต้นแล้ว ในรุ่นก่อนหน้าหนึ่งจะต้องทำ

std::vector<std::vector<int> > a;

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

อย่างไรก็ตามฉันไม่ทราบว่านี่เป็น "ชัดเจน" สำหรับคุณหรือไม่

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