คำถามติดแท็ก c++11

รับฟังก์ชั่นที่น่ารำคาญมาก int transform(int val) { return (val + 7) / 8; } มันควรจะชัดเจนว่ามันง่ายที่จะเปลี่ยนฟังก์ชั่นนี้เป็นconstexprฟังก์ชั่นทำให้ฉันใช้มันเมื่อกำหนดconstexprตัวแปรเช่น: constexpr int transform(int val) { return (val + 7) / 8; } ข้อสันนิษฐานของฉันคือสิ่งนี้เป็นการปรับปรุงอย่างเข้มงวดเนื่องจากฟังก์ชันยังสามารถเรียกใช้ในconstexprบริบทที่ไม่ได้และตอนนี้สามารถใช้เพื่อช่วยกำหนดตัวแปรค่าคงที่เวลาคอมไพล์ได้ คำถามของฉันคือมีสถานการณ์ที่นี่เป็นความคิดที่ไม่ดีหรือไม่? เช่นโดยการใช้ฟังก์ชั่นนี้constexprฉันจะเคยพบกับสถานการณ์ที่ฟังก์ชั่นนี้จะไม่สามารถใช้งานได้ในบางสถานการณ์หรือมันจะทำงานผิดปกติหรือไม่?

26 c++  c++11 

ฉันเพิ่งสงสัยว่าทำไมคำหลักที่autoถูกเลือกใน C ++ 11 เพื่อทำเครื่องหมายตัวแปรที่ต้องสรุปประเภทของคอมไพเลอร์เช่น auto x = 1; ตั้งแต่ var ดูเหมือนจะพบได้ทั่วไปในภาษาการเขียนโปรแกรมอื่น ๆ (เช่น C #, Scala, JavaScript) และ เท่าที่ฉันเข้าใจความหมายใหม่ของการautoแบ่งความเข้ากันได้แบบย้อนหลัง (ไม่ค่อยได้ใช้ แต่มีความหมายแตกต่างกันในการแก้ไข C ++ ก่อนหน้าดูตัวอย่างที่นี่ ) ฉันต้องการถามว่ามีเหตุผลพิเศษในการเลือกauto(เพื่อประโยชน์ของvarคำหลักอื่นหรือไม่) มีการอภิปรายเฉพาะเกี่ยวกับปัญหานี้ก่อนปล่อยมาตรฐาน C ++ 11 หรือไม่ นอกจากนี้ยังมีความเข้ากันไม่ได้ที่เราควรระวังเมื่อทำการคอมไพล์รหัส C ++ ใหม่ด้วยคอมไพเลอร์ C ++ 11 หรือไม่?

20 c++  c++11  type-systems 

ข้อดี / ข้อเสียของการใช้autoคำหลักโดยเฉพาะในลูปคืออะไร for(std::vector<T>::iterator it = x.begin(); it != x.end(); it++ ) { it->something(); } for(std::map<T>::iterator it = x.begin(); it != x.end(); it++ ) { it->second->something(); } for(auto it = x.begin(); it != x.end(); it++ ) { it->?? } ดูเหมือนว่าถ้าคุณไม่รู้ว่าคุณมีตัววนซ้ำสำหรับแผนที่หรือเวกเตอร์คุณจะไม่รู้ว่าจะใช้หรือไม่ firstหรือsecondเข้าถึงคุณสมบัติของวัตถุโดยตรงหรือไม่? สิ่งนี้ทำให้ฉันนึกถึงการโต้วาที C # ว่าจะใช้คำหลักvarหรือไม่ ความประทับใจที่ฉันได้รับจนถึงขณะนี้คือในโลกคน C ++ พร้อมที่จะใช้autoคำหลักที่มีการต่อสู้น้อยกว่าvarในโลก C …

20 c++  c++11 

"การเพิ่มประสิทธิภาพก่อนวัยอันควรเป็นรากฐานของความชั่วร้ายทั้งหมด" ฉันคิดว่าสิ่งนี้เราทุกคนสามารถตกลงกันได้ และฉันพยายามอย่างหนักเพื่อหลีกเลี่ยงการทำเช่นนั้น แต่เมื่อเร็ว ๆ นี้ผมได้รับการสงสัยเกี่ยวกับการปฏิบัติของพารามิเตอร์ผ่านโดยอ้างอิง constแทนโดยราคา ฉันได้รับการสอน / เรียนรู้ว่าการโต้แย้งฟังก์ชั่นที่ไม่สำคัญ (เช่นประเภทที่ไม่ใช่แบบดั้งเดิม) ควรจะถูกส่งผ่านโดยการอ้างอิง const - หนังสือบางเล่มที่ฉันได้อ่านแนะนำว่านี่เป็น "แนวปฏิบัติที่ดีที่สุด" ถึงกระนั้นฉันก็อดไม่ได้ที่จะสงสัย: คอมไพเลอร์สมัยใหม่และคุณสมบัติภาษาใหม่สามารถทำงานได้อย่างน่าอัศจรรย์ดังนั้นความรู้ที่ฉันได้เรียนรู้อาจล้าสมัยไปแล้วและฉันไม่เคยใส่ใจในโปรไฟล์เลยหากมีความแตกต่างระหว่างประสิทธิภาพ void fooByValue(SomeDataStruct data); และ void fooByReference(const SomeDataStruct& data); เป็นวิธีปฏิบัติที่ฉันได้เรียนรู้ - ผ่านการอ้างอิง const (โดยค่าเริ่มต้นสำหรับประเภทที่ไม่สำคัญ) - การเพิ่มประสิทธิภาพก่อนวัยอันควร?

20 c++  optimization  c++11 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว ฉันเคยเขียน C ++ อย่างกว้างขวางระหว่าง 8 และ 10 ปีที่แล้ว ฉันได้ย้ายไปยัง C # ด้วยเหตุผลมืออาชีพ อย่างไรก็ตามบางครั้งฉันเห็นข้อความชอบ "หากคุณยังคงติดตามการอ้างอิงตัวชี้ด้วยตนเองคุณกำลังทำผิด" หรือ "C ++ มีความปลอดภัยอย่างสมบูรณ์แบบตราบใดที่คุณใช้แนวคิดสมัยใหม่เช่น RAII และไม่ได้จัดสรรหน่วยความจำด้วยตนเองเช่นนักพัฒนา C ที่กู้คืน" ทั้งสองเป็นขั้นตอนมาตรฐานเมื่อสิบปีที่แล้ว ฉันได้เห็นว่า C ++ ได้รับการปรับปรุงอย่างมากในช่วงเวลาที่ผ่านมา; โดยเฉพาะอย่างยิ่ง C ++ 0x ดูเหมือนจะมีความสามารถใหม่ ๆ แหล่งข้อมูลที่ดีที่สุดสำหรับโปรแกรมเมอร์ "C / old C ++" …

16 c++  design-patterns  c  programming-practices  c++11 

ฉันทำงานเฉพาะใน C ++ 11/14 และมักจะประจบประแจงเมื่อฉันเห็นรหัสเช่นนี้ std::int64_t mArray; mArray |= someMask << 1; นี่เป็นเพียงตัวอย่างเท่านั้น ฉันกำลังพูดถึงการจัดการบิตที่ชาญฉลาดโดยทั่วไป ใน C ++ มีจุดใดจริง ๆ หรือไม่ ข้างต้นคือการแปรปรวนของจิตใจและข้อผิดพลาดได้ง่ายในขณะที่ใช้std::bitsetช่วยให้คุณ: ปรับเปลี่ยนขนาดของstd::bitsetสิ่งที่ต้องการได้ง่ายขึ้นโดยการปรับพารามิเตอร์เทมเพลตและให้การใช้งานสามารถจัดการส่วนที่เหลือและ ใช้เวลาน้อยลงในการหาว่าเกิดอะไรขึ้น (และอาจทำผิดพลาด) และเขียนstd::bitsetในลักษณะที่คล้ายกับstd::arrayหรือบรรจุข้อมูลอื่น ๆ คำถามของฉันคือ; มีเหตุผลที่จะไม่ใช้std::bitsetกับประเภทดั้งเดิมอื่น ๆ นอกเหนือจากความเข้ากันได้ย้อนหลัง?

16 c++  c++11  bitwise-operators 

รหัสต่อไปนี้ดูไม่เป็นอันตรายเมื่อพบเห็นครั้งแรก ผู้ใช้ใช้ฟังก์ชันbar()เพื่อโต้ตอบกับฟังก์ชันไลบรารีบางอย่าง (ซึ่งอาจจะมีการทำงานถึงแม้จะเป็นเวลานานตั้งแต่bar()กลับอ้างอิงถึงค่าที่ไม่ใช่ชั่วคราวหรือคล้ายกัน.) Bแต่ตอนนี้มันเป็นเพียงการกลับตัวอย่างใหม่ของ Bอีกครั้งมีฟังก์ชั่นที่ผลตอบแทนอ้างอิงกับวัตถุชนิดa() iterateable Aผู้ใช้ต้องการสอบถามวัตถุนี้ซึ่งนำไปสู่ ​​segfault เนื่องจากBวัตถุชั่วคราวที่ส่งคืนโดยbar()ถูกทำลายก่อนที่จะเริ่มซ้ำ ฉันไม่แน่ใจว่าใคร (ห้องสมุดหรือผู้ใช้) ที่จะตำหนิสำหรับสิ่งนี้ ห้องสมุดทั้งหมดที่มีให้ชั้นเรียนดูสะอาดสำหรับฉันและแน่นอนว่าไม่ได้ทำอะไรที่แตกต่างกัน (การส่งคืนการอ้างอิงถึงสมาชิก, การคืนอินสแตนซ์สแต็ก, ... ) กว่าโค้ดอื่น ๆ ผู้ใช้ดูเหมือนจะไม่ทำอะไรผิดปกติเช่นกันเขาแค่ทำซ้ำวัตถุบางอย่างโดยไม่ทำอะไรเกี่ยวกับวัตถุนั้นตลอดชีวิต (คำถามที่เกี่ยวข้องอาจเป็น: หนึ่งควรสร้างกฎทั่วไปว่ารหัสไม่ควร "ช่วงตามสำหรับ - ซ้ำ" เหนือสิ่งที่ถูกดึงโดยมากกว่าหนึ่งสายที่ถูกล่ามโซ่ในส่วนหัววนเนื่องจากการโทรใด ๆ เหล่านี้อาจกลับ rvalue?) #include <algorithm> #include <iostream> // "Library code" struct A { A(): v{0,1,2} { std::cout << "A()" << std::endl; } ~A() { …

15 c++11 

ฉันรู้ว่านี่เป็นวิธีปฏิบัติที่ถกเถียงกัน แต่สมมติว่านี่เป็นตัวเลือกที่ดีที่สุดสำหรับฉัน ฉันสงสัยเกี่ยวกับเทคนิคที่แท้จริงในการทำสิ่งนี้ วิธีการที่ฉันเห็นคือ: 1) สร้างคลาสเพื่อนที่เป็นคลาสที่ฉันต้องการทดสอบ 2) ในคลาสเพื่อนสร้างวิธีสาธารณะที่เรียกวิธีส่วนตัวของคลาสที่ทดสอบ 3) ทดสอบวิธีสาธารณะของเพื่อนชั้น นี่เป็นตัวอย่างง่ายๆที่แสดงให้เห็นถึงขั้นตอนข้างต้น: #include <iostream> class MyClass { friend class MyFriend; // Step 1 private: int plus_two(int a) { return a + 2; } }; class MyFriend { public: MyFriend(MyClass *mc_ptr_1) { MyClass *mc_ptr = mc_ptr_1; } int plus_two(int a) // Step …

15 c++  unit-testing  class  c++11 

ดูบทความนี้เกี่ยวกับความปลอดภัยของการเกิดพร้อมกันของ Rust: http://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html ฉันสงสัยว่าความคิดเหล่านี้สามารถทำได้ใน C ++ 11 (หรือใหม่กว่า) โดยเฉพาะอย่างยิ่งฉันสามารถสร้างคลาสของเจ้าของที่โอนความเป็นเจ้าของไปยังวิธีการใด ๆ ที่มันอาจจะผ่าน? ดูเหมือนว่า C ++ มีหลายวิธีในการส่งผ่านตัวแปรที่เป็นไปไม่ได้ แต่บางทีฉันอาจวางข้อ จำกัด บางอย่างในคลาสหรือเทมเพลตเพื่อให้แน่ใจว่าโค้ดเทมเพลตบางตัวได้รับการประมวลผลด้วยวิธีการส่งผ่านทุกครั้งหรือไม่

15 concurrency  c++11  rust 

ฉันเพิ่งทำงานในสถานการณ์ต่อไปนี้ class A{ public: void calculate(T inputs); } ประการแรกAแสดงถึงวัตถุในโลกทางกายภาพซึ่งเป็นข้อโต้แย้งที่แข็งแกร่งที่ไม่แยกชั้นเรียนขึ้น ตอนนี้calculate()กลายเป็นฟังก์ชั่นที่ค่อนข้างยาวและซับซ้อน ฉันเข้าใจโครงสร้างที่เป็นไปได้สามประการ: เขียนเป็นกำแพงข้อความ - ข้อดี - ข้อมูลทั้งหมดอยู่ในที่เดียว เขียนprivateฟังก์ชั่นยูทิลิตี้ในชั้นเรียนและใช้พวกเขาในcalculateร่างกาย - ข้อเสีย - ส่วนที่เหลือของชั้นไม่ทราบ / ดูแล / เข้าใจเกี่ยวกับวิธีการเหล่านั้น เขียนcalculateวิธีดังต่อไปนี้: void A::calculate(T inputs){ auto lambda1 = () [] {}; auto lambda2 = () [] {}; auto lambda3 = () [] {}; lambda1(inputs.first_logical_chunk); lambda2(inputs.second_logical_chunk); lambda3(inputs.third_logical_chunk); …

14 c++11  lambda 

เมื่อฉันเรียนรู้ C ++ นานมาแล้วมันเน้นอย่างมากกับฉันว่าส่วนหนึ่งของจุดของ C ++ คือเหมือนลูปมี "loop-invariants" คลาสยังมีค่าคงที่ที่เกี่ยวข้องกับอายุการใช้งานของวัตถุ - สิ่งที่ควรเป็นจริง เพราะตราบเท่าที่วัตถุยังมีชีวิตอยู่ สิ่งที่ควรกำหนดโดยผู้สร้างและเก็บรักษาไว้โดยวิธีการ การห่อหุ้ม / การควบคุมการเข้าถึงมีไว้เพื่อช่วยให้คุณบังคับใช้ค่าคงที่ Raii เป็นสิ่งหนึ่งที่คุณสามารถทำได้กับความคิดนี้ ตั้งแต่ C ++ 11 ตอนนี้เรามีความหมายย้าย สำหรับคลาสที่รองรับการย้ายการย้ายจากวัตถุไม่สิ้นสุดอย่างเป็นทางการตลอดอายุการย้ายควรจะปล่อยให้มันอยู่ในสถานะ "ถูกต้อง" บางอย่าง ในการออกแบบชั้นเรียนเป็นเรื่องที่ไม่ถูกต้องหรือไม่หากคุณออกแบบชั้นเรียนเพื่อให้ค่าคงที่ของชั้นเรียนถูกเก็บรักษาไว้จนถึงจุดที่ถูกย้ายออกไป หรือว่าไม่เป็นไรถ้ามันจะช่วยให้คุณทำให้มันเร็วขึ้น หากต้องการทำให้เป็นรูปธรรมสมมติว่าฉันมีประเภททรัพยากรที่ไม่สามารถคัดลอกได้ แต่เคลื่อนย้ายได้เช่น: class opaque { opaque(const opaque &) = delete; public: opaque(opaque &&); ... void mysterious(); void mysterious(int); void mysterious(std::vector<std::string>); }; และด้วยเหตุผลใดก็ตามฉันจำเป็นต้องทำ …

13 c++  object-oriented-design  c++11  invariants 

ส่วนใหญ่ทำงานเขียนโปรแกรมภาษา (เช่น Common เสียงกระเพื่อมโครงการ / แร็กเก็ต, Clojure, Haskell, สกาล่า Ocaml, SML) สนับสนุนบางส่วนทำงานร่วมกันขั้นสูงในรายการเช่นmap, filter, takeWhile, dropWhile, foldl, foldr(ดูเช่นCommon เสียงกระเพื่อมโครงการ / แร็กเก็ต, Clojure เอกสารอ้างอิงแบบเคียงข้างกัน , เอกสารHaskell , Scala , OCamlและSML ) C ++ 11 มีวิธีการหรือฟังก์ชั่นมาตรฐานที่เทียบเท่าในรายการหรือไม่? ตัวอย่างเช่นลองพิจารณาตัวอย่าง Haskell ต่อไปนี้: let xs = [1, 2, 3, 4, 5] let ys = map (\x -> …

13 c++  functional-programming  c++11  lambda  list 

เรากำลังทดสอบห้องสมุดภายใต้ C ++ 11 (เช่น-std=c++11) ห้องสมุดใช้auto_ptrและรูปแบบนี้: Foo* GetFoo() { autoptr<Foo> ptr(new Foo); // Initialize Foo ptr->Initialize(...); // Now configure remaining attributes ptr->SomeSetting(...); return ptr.release(); } เลิกใช้ C ++ 11 auto_ptrดังนั้นเราต้องการย้ายออกไป อย่างไรก็ตามรหัสสนับสนุนทั้ง C ++ 03 และ C ++ 11 จึงไม่ง่ายที่เป็น auto_ptryanking นอกจากนี้ยังมีมูลค่าการกล่าวถึงห้องสมุดที่ไม่มีการอ้างอิงภายนอก มันใช้ C ++ 03; และไม่ใช้ Autotools, Cmake, Boost, ... …

12 design  c++  c++11 

ฉันทำงานกับแอพพลิเคชั่นซอฟต์แวร์ขนาดใหญ่ที่ต้องใช้งานบนหลายแพลตฟอร์ม บางแพลตฟอร์มเหล่านี้รองรับคุณสมบัติบางอย่างของ C ++ 11 (เช่น MSVS 2010) และบางแพลตฟอร์มไม่รองรับ (เช่น GCC 4.3.x) ฉันคาดว่าสถานการณ์นี้จะดำเนินต่อไปอีกหลายปี (คาดเดาที่ดีที่สุดของฉัน: 3-5 ปี) เนื่องจากว่าฉันต้องการตั้งค่าอินเทอร์เฟซที่ใช้งานร่วมกันได้ซึ่งผู้คนสามารถเขียนโค้ด C ++ 11 ที่จะยังคงคอมไพล์ด้วยคอมไพเลอร์รุ่นเก่าที่มีความเป็นไปได้ในระดับใดก็ตาม โดยรวมแล้วเป้าหมายคือการลด # ifdef ให้มากที่สุดเท่าที่จะเป็นไปได้ในขณะที่ยังคงเปิดใช้งานไวยากรณ์ / คุณสมบัติ C ++ 11 พื้นฐานบนแพลตฟอร์มที่สนับสนุนพวกเขาและให้การจำลองบนแพลตฟอร์มที่ไม่รองรับ เริ่มต้นด้วย std :: move () วิธีที่ชัดเจนที่สุดในการบรรลุความเข้ากันได้คือการใส่บางอย่างในไฟล์ส่วนหัวร่วม: #if !defined(HAS_STD_MOVE) namespace std { // C++11 emulation template <typename T> inline T& …

12 c++  c++11 

สามารถคอมไพเลอร์ C ++ รุ่นเก่า (เช่น VS2008 และ gcc3.4) เชื่อมโยงกับไลบรารีภายนอกที่เขียนด้วย C ++ 11 ได้หรือไม่? ความคิดของฉันคือไฟล์ C ++ 11 .lib เป็นเพียงโค้ดไบต์ในขั้นตอนนี้และไม่ควรรบกวนคอมไพเลอร์รุ่นเก่าที่สร้างขึ้นมาตราบใดที่มันสามารถแก้ไขและเรียกใช้ได้ ฉันกำลังพัฒนาห้องสมุดขนาดเล็กซึ่ง API ยังควรสนับสนุนผู้ใช้ C ++ 03 ดังนั้นมองไปข้างหน้าฉันสงสัยว่ามันโอเคที่จะใช้ห้องสมุดของฉันโดยใช้คุณสมบัติที่เป็นประโยชน์std::unique_ptrเช่นนี้หรือไม่หรือฉันต้องติดกับboost::?

12 c++  c++11