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

สมมติว่าฉันมีคำสั่งจำนวนหนึ่งที่ฉันต้องการดำเนินการตามลำดับคงที่ ฉันต้องการใช้ g ++ กับการเพิ่มประสิทธิภาพระดับ 2 ดังนั้นจึงสามารถจัดเรียงคำสั่งใหม่ได้ มีเครื่องมืออะไรบ้างในการบังคับใช้คำสั่งบางอย่าง ลองพิจารณาตัวอย่างต่อไปนี้ using Clock = std::chrono::high_resolution_clock; auto t1 = Clock::now(); // Statement 1 foo(); // Statement 2 auto t2 = Clock::now(); // Statement 3 auto elapsedTime = t2 - t1; ในตัวอย่างนี้เป็นสิ่งสำคัญที่จะต้องดำเนินการคำสั่ง 1-3 ตามลำดับที่กำหนด อย่างไรก็ตามคอมไพเลอร์ไม่สามารถคิดว่าคำสั่ง 2 เป็นอิสระจาก 1 และ 3 และรันโค้ดดังนี้ได้หรือไม่? using Clock=std::chrono::high_resolution_clock; foo(); …

111 c++  c++11  operator-precedence 

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

110 c++  c++11  module  standards  language-extension 

ในขณะที่เรียกดูการใช้งานส่วนหัว C ++ 11 ใหม่ในปัจจุบันของ gcc ฉันพบโทเค็น "...... " คุณสามารถตรวจสอบได้ว่าโค้ดต่อไปนี้คอมไพล์ดี [ผ่าน ideone.com] template <typename T> struct X { /* ... */ }; template <typename T, typename ... U> struct X<T(U......)> // this line is the important one { /* ... */ }; ความหมายของโทเค็นนี้คืออะไร? แก้ไข: ดูเหมือนว่า SO ถูกตัด "...... " ในชื่อคำถามเป็น …

110 c++  c++11  variadic-templates 

ฉันอยากรู้ว่าstd:next_permutationมีการใช้งานอย่างไรดังนั้นฉันจึงแยกgnu libstdc++ 4.7เวอร์ชันและทำความสะอาดตัวระบุและการจัดรูปแบบเพื่อสร้างการสาธิตต่อไปนี้ ... #include <vector> #include <iostream> #include <algorithm> using namespace std; template<typename It> bool next_permutation(It begin, It end) { if (begin == end) return false; It i = begin; ++i; if (i == end) return false; i = end; --i; while (true) { It j = i; --i; …

110 c++  c++11  permutation  stl-algorithm  lexicographic 

ฉันเป็นผู้เริ่มต้นใช้งาน C ++ แต่ไม่ใช่ผู้เริ่มเขียนโปรแกรม ฉันกำลังพยายามเรียนรู้ C ++ (c ++ 11) และมันก็ไม่ชัดเจนสำหรับฉันสิ่งที่สำคัญที่สุด: การส่งผ่านพารามิเตอร์ ฉันพิจารณาตัวอย่างง่ายๆเหล่านี้: คลาสที่มีสมาชิกทุกประเภทดั้งเดิม: CreditCard(std::string number, int expMonth, int expYear,int pin):number(number), expMonth(expMonth), expYear(expYear), pin(pin) คลาสที่มีเป็นสมาชิกประเภทดั้งเดิม + 1 ประเภทที่ซับซ้อน: Account(std::string number, float amount, CreditCard creditCard) : number(number), amount(amount), creditCard(creditCard) คลาสที่มีเป็นสมาชิกประเภทดั้งเดิม + 1 คอลเลกชันที่ซับซ้อนบางประเภท: Client(std::string firstName, std::string lastName, std::vector<Account> accounts):firstName(firstName), lastName(lastName), accounts(accounts) …

108 c++  c++11 

ไม่ C ++ 11 ห้องสมุดมาตรฐานให้ยูทิลิตี้ใด ๆ ที่จะแปลงจากstd::shared_ptrไปstd::unique_ptrหรือกลับกัน? การดำเนินการนี้ปลอดภัยหรือไม่?

108 c++  c++11  shared-ptr  unique-ptr 

ฉันจะใช้ตัวสร้างการคัดลอกสำหรับคลาสที่มีunique_ptrตัวแปรสมาชิกได้อย่างไร ฉันกำลังพิจารณาเฉพาะ C ++ 11

107 c++  c++11  unique-ptr 

ค่าโสหุ้ยของตัวชี้อัจฉริยะเทียบกับพอยน์เตอร์ปกติใน C ++ 11 เป็นเท่าใด กล่าวอีกนัยหนึ่งรหัสของฉันจะช้าลงหรือไม่หากฉันใช้ตัวชี้อัจฉริยะและถ้าเป็นเช่นนั้นจะช้าลงเท่าใด โดยเฉพาะฉันถามเกี่ยวกับ C ++ 11 std::shared_ptrและstd::unique_ptr. เห็นได้ชัดว่าสิ่งที่ผลักลงในสแต็กจะมีขนาดใหญ่ขึ้น (อย่างน้อยฉันก็คิดอย่างนั้น) เนื่องจากตัวชี้อัจฉริยะจำเป็นต้องเก็บสถานะภายในไว้ด้วย (จำนวนอ้างอิง ฯลฯ ) คำถามก็คือสิ่งนี้จะเป็นเท่าใด ส่งผลกระทบต่อประสิทธิภาพการทำงานของฉันหรือไม่ ตัวอย่างเช่นฉันส่งคืนตัวชี้อัจฉริยะจากฟังก์ชันแทนที่จะเป็นตัวชี้ปกติ: std::shared_ptr<const Value> getValue(); // versus const Value *getValue(); หรือตัวอย่างเช่นเมื่อฟังก์ชันหนึ่งของฉันยอมรับตัวชี้อัจฉริยะเป็นพารามิเตอร์แทนที่จะเป็นตัวชี้ปกติ: void setValue(std::shared_ptr<const Value> val); // versus void setValue(const Value *val);

107 c++  performance  c++11  smart-pointers 

ฉันกำลังอ่านhttp://gcc.gnu.org/onlinedocs/libstdc++/manual/shared_ptr.htmlและปัญหาด้านความปลอดภัยของเธรดยังไม่ชัดเจนสำหรับฉัน: มาตรฐานรับประกันว่าการนับอ้างอิงได้รับการจัดการเธรดอย่างปลอดภัยและเป็นอิสระจากแพลตฟอร์มใช่ไหม ปัญหาที่คล้ายกัน - มาตรฐานรับประกันว่าเธรดเดียวเท่านั้น (ถือการอ้างอิงสุดท้าย) จะเรียกลบในวัตถุที่แชร์ใช่ไหม shared_ptr ไม่รับประกันความปลอดภัยของเธรดใด ๆ สำหรับอ็อบเจ็กต์ที่เก็บอยู่ในนั้น? แก้ไข: รหัสหลอก: // Thread I shared_ptr<A> a (new A (1)); // Thread II shared_ptr<A> b (a); // Thread III shared_ptr<A> c (a); // Thread IV shared_ptr<A> d (a); d.reset (new A (10)); การเรียกการรีเซ็ต () ในเธรด IV จะลบอินสแตนซ์ก่อนหน้าของคลาส A ที่สร้างในเธรดแรกและแทนที่ด้วยอินสแตนซ์ใหม่? …

106 c++  c++11  shared-ptr 

ด้วย C ++ 11 std::arrayฉันรับประกันว่าไวยากรณ์std::array<T, N> x;จะเริ่มต้นองค์ประกอบทั้งหมดของอาร์เรย์เป็นค่าเริ่มต้นหรือไม่ แก้ไข : ถ้าไม่มีมีไวยากรณ์ที่จะทำงานกับอาร์เรย์ทั้งหมด (รวมถึงอาร์เรย์ขนาดศูนย์) เพื่อเริ่มต้นองค์ประกอบทั้งหมดเป็นค่าเริ่มต้นหรือไม่ แก้ไข : ในcppreferenceคำอธิบายตัวสร้างเริ่มต้นกล่าวว่า: (constructor) (implicitly declared) (public member function) default-constructs or copy-constructs every element of the array ดังนั้นคำตอบอาจเป็นใช่ แต่ฉันต้องการให้แน่ใจว่าเป็นไปตามมาตรฐานหรือมาตรฐานในอนาคต

106 c++11  initialization  default-constructor  stdarray 

พิจารณาฟังก์ชันอินไลน์ต่อไปนี้: // Inline specifier version #include<iostream> #include<cstdlib> inline int f(const int x); inline int f(const int x) { return 2*x; } int main(int argc, char* argv[]) { return f(std::atoi(argv[1])); } และเวอร์ชันที่เทียบเท่า constexpr: // Constexpr specifier version #include<iostream> #include<cstdlib> constexpr int f(const int x); constexpr int f(const int x) { return …

105 c++  c++11  inline  standards-compliance  constexpr 

ฉันเพิ่งพบว่าตัวเองไม่เข้าใจตรรกะของstd::move(). ตอนแรกฉันใช้ googled แต่ดูเหมือนว่าจะมีเพียงเอกสารเกี่ยวกับวิธีใช้std::move()ไม่ใช่วิธีการทำงานของโครงสร้าง ฉันหมายความว่าฉันรู้ว่าฟังก์ชันสมาชิกเทมเพลตคืออะไร แต่เมื่อฉันดูstd::move()คำจำกัดความใน VS2010 ก็ยังสับสน คำจำกัดความของ std :: move () อยู่ด้านล่าง template<class _Ty> inline typename tr1::_Remove_reference<_Ty>::_Type&& move(_Ty&& _Arg) { // forward _Arg as movable return ((typename tr1::_Remove_reference<_Ty>::_Type&&)_Arg); } สิ่งที่แปลกก่อนสำหรับฉันคือพารามิเตอร์ (_Ty && _Arg) เพราะเมื่อฉันเรียกใช้ฟังก์ชันอย่างที่คุณเห็นด้านล่าง // main() Object obj1; Object obj2 = std::move(obj1); โดยพื้นฐานแล้วมันเท่ากับ // std::move() _Ty&& _Arg = …

105 c++  c++11  move-semantics 

มีวิธีตรวจจับในเวลาคอมไพล์หรือไม่ว่าคอมไพเลอร์รองรับคุณสมบัติบางอย่างของ C ++ 11 หรือไม่? ตัวอย่างเช่นสิ่งนี้: #ifndef VARIADIC_TEMPLATES_SUPPORTED #error "Your compiler doesn't support variadic templates. :(" #else template <typename... DatatypeList> class Tuple { // ... } #endif

104 c++  c++11 

ทำไมถึงต้องมีstd::reference_wrapper? ควรใช้ที่ไหน? ต่างจากพอยน์เตอร์ธรรมดาอย่างไร? ประสิทธิภาพของมันเปรียบเทียบกับตัวชี้ธรรมดาอย่างไร?

104 c++  pointers  c++11  reference  reference-wrapper 

ด้วย range-based ใหม่สำหรับลูปเราสามารถเขียนโค้ดเช่น for(auto x: Y) {} IMO ใดเป็นการปรับปรุงครั้งใหญ่จาก (เช่น) for(std::vector<int>::iterator x=Y.begin(); x!=Y.end(); ++x) {} สามารถใช้เพื่อวนซ้ำสองลูปพร้อมกันเช่นzipฟังก์ชันPythons ได้หรือไม่? สำหรับผู้ที่ไม่คุ้นเคยกับ Python รหัส: Y1 = [1,2,3] Y2 = [4,5,6,7] for x1,x2 in zip(Y1,Y2): print x1,x2 ให้เป็นผลลัพธ์ (1,4) (2,5) (3,6)

104 c++  c++11  sequences