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

ตามที่ชื่อแนะนำฉันกำลังพยายามหาวิธีสร้างตัวเลขสุ่มโดยใช้<random>ไลบรารีC ++ 11 ใหม่ ฉันได้ลองใช้รหัสนี้แล้ว: std::default_random_engine generator; std::uniform_real_distribution<double> uniform_distance(1, 10.001); ปัญหาเกี่ยวกับรหัสที่ฉันมีคือทุกครั้งที่ฉันรวบรวมและเรียกใช้มันจะสร้างตัวเลขเดียวกันเสมอ ดังนั้นคำถามของฉันคือฟังก์ชั่นอื่น ๆ ในไลบรารีสุ่มสามารถทำสิ่งนี้ได้ในขณะที่สุ่มอย่างแท้จริง? สำหรับกรณีการใช้งานโดยเฉพาะของฉันฉันพยายามหาค่าภายในช่วง [1, 10]

143 c++  c++11  random  range 

ใน C ++ แบบดั้งเดิมการส่งผ่านค่าไปยังฟังก์ชั่นและวิธีการจะช้าสำหรับวัตถุขนาดใหญ่และโดยทั่วไปจะขมวดคิ้ว แต่โปรแกรมเมอร์ C ++ มักจะส่งต่อการอ้างอิงไปรอบ ๆ ซึ่งเร็วกว่า แต่แนะนำคำถามที่ซับซ้อนทุกประเภทเกี่ยวกับการเป็นเจ้าของและโดยเฉพาะการจัดการหน่วยความจำ (ในกรณีที่วัตถุจัดสรรเป็นฮีป) ตอนนี้ใน C ++ 11 เรามี Rvalue reference และ move constructors ซึ่งหมายความว่ามันเป็นไปได้ที่จะใช้ object ขนาดใหญ่ (เช่นstd::vector) ที่ราคาถูกเพื่อส่งผ่านค่าเข้าและออกจากฟังก์ชัน ดังนั้นนี่หมายความว่าค่าเริ่มต้นควรจะส่งผ่านตามค่าสำหรับอินสแตนซ์ของประเภทเช่นstd::vectorและstd::string? แล้ววัตถุที่กำหนดเองล่ะ? แนวปฏิบัติที่ดีที่สุดแบบใหม่คืออะไร

142 c++  coding-style  c++11 

ฉันเข้าใจว่าแลมบ์ดาเป็นตัวชี้ฟังก์ชั่น เมื่อฉันทำการทดสอบต่อไปนี้ฉันพบว่ามันผิด ( สาธิต ) #define LAMBDA [] (int i) -> long { return 0; } int main () { long (*pFptr)(int) = LAMBDA; // ok auto pAuto = LAMBDA; // ok assert(typeid(pFptr) == typeid(pAuto)); // assertion fails ! } รหัสข้างต้นหายไปจุดใด? ถ้าไม่เช่นtypeofนั้นแลมบ์ดานิพจน์คืออะไรเมื่ออนุมานด้วยautoคำหลัก?

142 c++  lambda  c++11  typeof  auto 

เมื่อใช้ฟังก์ชั่นการโทรกลับใน C ++ ฉันควรจะใช้ตัวชี้ฟังก์ชั่น C-style: void (*callbackFunc)(int); หรือฉันควรใช้ประโยชน์จากฟังก์ชั่น std :: std::function< void(int) > callbackFunc;

142 c++  function  c++11  callback  std 

ตามเนื้อผ้าวิธีมาตรฐานและแบบพกพาเพื่อหลีกเลี่ยงการรวมส่วนหัวหลายรายการใน C ++ คือ / คือการใช้#ifndef - #define - #endifชุดรูปแบบคำสั่ง pre-compiler หรือที่เรียกว่าชุดรูปแบบมหภาคการ์ด (ดูตัวอย่างรหัสด้านล่าง) #ifndef MY_HEADER_HPP #define MY_HEADER_HPP ... #endif ในการใช้งานมากที่สุด / คอมไพเลอร์ (ดูภาพด้านล่าง) แต่มีอีกทางเลือก "สง่างาม" #pragma onceที่ทำหน้าที่วัตถุประสงค์เช่นเดียวกับโครงการแมโครยามที่เรียกว่า #pragma onceมีข้อดีหลายประการเมื่อเทียบกับชุดรูปแบบการป้องกันมาโครซึ่งรวมถึงรหัสน้อยกว่าการหลีกเลี่ยงการปะทะกันของชื่อและบางครั้งการปรับปรุงความเร็วในการคอมไพล์ ฉันทำการวิจัยบางอย่างฉันรู้ว่าถึงแม้#pragma onceคำสั่งจะได้รับการสนับสนุนจากคอมไพเลอร์ที่รู้จักกันเกือบทั้งหมด แต่ก็มีความขุ่นเคืองว่า#pragma onceคำสั่งนั้นเป็นส่วนหนึ่งของมาตรฐาน C ++ 11 หรือไม่ คำถาม: บางคนสามารถอธิบายได้ว่า#pragma onceคำสั่งนั้นเป็นส่วนหนึ่งของมาตรฐาน C ++ 11 หรือไม่? หากไม่ได้เป็นส่วนหนึ่งของมาตรฐาน C ++ 11 มีแผนใดบ้างในการรวมไว้ในรุ่นที่ใหม่กว่า (เช่น …

140 c++  c++11  macros  header-files  c++14 

บางครั้งฉันต้องใช้std::threadเพื่อเร่งความเร็วการสมัครของฉัน ฉันก็รู้เช่นกันjoin()รอจนกว่าเธรดจะเสร็จสมบูรณ์ สิ่งนี้ง่ายต่อการเข้าใจ แต่ความแตกต่างระหว่างการโทรdetach()และไม่เรียกมันคืออะไร ฉันคิดว่าไม่มีdetach()วิธีของเธรดจะทำงานโดยใช้เธรดอย่างอิสระ ไม่ถอด: void Someclass::Somefunction() { //... std::thread t([ ] { printf("thread called without detach"); }); //some code here } การโทรด้วยการถอดออก: void Someclass::Somefunction() { //... std::thread t([ ] { printf("thread called with detach"); }); t.detach(); //some code here }

140 c++  c++11  stdthread 

ฉันไม่จำเป็นต้องยุติเธรดอย่างถูกต้องหรือทำให้มันตอบสนองต่อคำสั่ง "ยุติ" ฉันสนใจที่จะยุติเธรดโดยใช้ C ++ 11 ล้วนๆ

140 c++  multithreading  c++11 

C ++ 11เปิดตัวอักษรที่ผู้ใช้กำหนดซึ่งจะช่วยให้การแนะนำของไวยากรณ์ตัวอักษรใหม่บนพื้นฐานของตัวอักษรที่มีอยู่ ( int, hex, string, float) เพื่อให้ใช้วิธีใดจะสามารถที่จะมีการนำเสนอที่แท้จริง ตัวอย่าง: // imaginary numbers std::complex<long double> operator "" _i(long double d) // cooked form { return std::complex<long double>(0, d); } auto val = 3.14_i; // val = complex<long double>(0, 3.14) // binary values int operator "" _B(const char*); // raw form …

139 c++  c++11  user-defined-literals 

ฉันรู้สึกประหลาดใจอย่างยิ่งที่โค้ดต่อไปนี้รวบรวมและทำงาน (vc2012 & gcc4.7.2) class Foo { struct Bar { int i; }; public: Bar Baz() { return Bar(); } }; int main() { Foo f; // Foo::Bar b = f.Baz(); // error auto b = f.Baz(); // ok std::cout << b.i; } ถูกต้องหรือไม่ว่ารหัสนี้รวบรวมได้ดี และทำไมมันถูกต้อง? เหตุใดฉันสามารถใช้autoกับประเภทส่วนตัวในขณะที่ฉันไม่สามารถใช้ชื่อได้ (ตามที่คาดไว้)

139 c++  c++11  auto  private-members 

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

139 c++  c++11  coding-style  effective-c++ 

มาตรฐานกำหนดสิ่งที่ฉันสามารถทำกับวัตถุได้อย่างแม่นยำเมื่อมันถูกย้ายจากหรือไม่? ฉันเคยคิดว่าทุกสิ่งที่คุณสามารถทำได้ด้วยวัตถุที่ย้ายจากไปนั้นทำลายมัน แต่นั่นก็ไม่เพียงพอ ตัวอย่างเช่นใช้เทมเพลตฟังก์ชันswapตามที่กำหนดไว้ในไลบรารีมาตรฐาน: template <typename T> void swap(T& a, T& b) { T c = std::move(a); // line 1 a = std::move(b); // line 2: assignment to moved-from object! b = std::move(c); // line 3: assignment to moved-from object! } เห็นได้ชัดว่ามันจะต้องเป็นไปได้ที่จะกำหนดให้กับการย้ายจากวัตถุมิฉะนั้นบรรทัดที่ 2 และ 3 จะล้มเหลว แล้วฉันจะทำยังไงกับวัตถุที่ถูกย้าย? ฉันจะหารายละเอียดเหล่านี้ได้จากที่ไหน? (อย่างไรก็ตามทำไมมันT c …

138 c++  c++11  variable-assignment  swap  move-semantics 

ความสามารถในการสร้างและจัดการสตริงระหว่างเวลาคอมไพล์ใน C ++ มีแอพพลิเคชั่นที่มีประโยชน์มากมาย แม้ว่าจะสามารถสร้างสตริงเวลาคอมไพล์ใน C ++ ได้ แต่กระบวนการนี้ยุ่งยากมากเนื่องจากต้องประกาศสตริงเป็นลำดับตัวแปรของอักขระเช่น using str = sequence<'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!'>; การดำเนินการเช่นการต่อสายอักขระการแยกสตริงย่อยและอื่น ๆ อีกมากมายสามารถนำไปใช้งานได้อย่างง่ายดายเป็นการดำเนินการกับลำดับของอักขระ เป็นไปได้ไหมที่จะประกาศสตริงเวลาคอมไพล์สะดวกกว่า ถ้าไม่มีมีข้อเสนอในผลงานที่อนุญาตให้มีการประกาศสตริงเวลาคอมไพล์ได้อย่างสะดวกหรือไม่? เหตุใดแนวทางที่มีอยู่จึงล้มเหลว ตามหลักการแล้วเราต้องการที่จะสามารถประกาศสตริงเวลาคอมไพล์ได้ดังนี้: // Approach 1 using str1 = sequence<"Hello, world!">; หรือใช้ตัวอักษรที่ผู้ใช้กำหนดเอง // Approach 2 constexpr auto str2 = "Hello, …

138 c++  string  c++11  metaprogramming  user-defined-literals 

ฉันสับสนกับความแตกต่างระหว่างอนาคตกับคำสัญญา เห็นได้ชัดว่าพวกเขามีวิธีการและสิ่งต่าง ๆ แต่กรณีการใช้งานจริงเป็นอย่างไร? ใช่ไหม?: เมื่อฉันจัดการงาน async ฉันใช้อนาคตเพื่อรับค่า "ในอนาคต" เมื่อฉันเป็นงาน async ฉันใช้สัญญาเป็นประเภทการส่งคืนเพื่อให้ผู้ใช้ได้รับอนาคตจากสัญญาของฉัน

138 c++  c++11  promise  future 

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

137 c++  c++11  operator-overloading  logical-operators  short-circuiting 

(หมายเหตุ: คำถามนี้เป็นคำถามเกี่ยวกับการไม่ต้องระบุจำนวนขององค์ประกอบและยังคงอนุญาตให้มีชนิดที่ซ้อนกันที่จะเริ่มต้นได้โดยตรง.) คำถามนี้กล่าวถึงการใช้งานที่เหลือสำหรับอาร์เรย์ C int arr[20];เช่น ในคำตอบของเขา @James Kanze แสดงหนึ่งในฐานที่มั่นสุดท้ายของอาร์เรย์ C มันเป็นลักษณะการเริ่มต้นที่ไม่ซ้ำกัน: int arr[] = { 1, 3, 3, 7, 0, 4, 2, 0, 3, 1, 4, 1, 5, 9 }; เราไม่ต้องระบุจำนวนองค์ประกอบไชโย! ทีนี้วนซ้ำด้วยฟังก์ชัน C ++ 11 std::beginและstd::endจาก<iterator>( หรือตัวแปรของคุณเอง ) และคุณไม่จำเป็นต้องคิดถึงขนาดของมัน ตอนนี้มีวิธีใดบ้าง (ที่เป็นไปได้ของ TMP) ในการบรรลุเป้าหมายเดียวกันstd::arrayหรือไม่? อนุญาตให้ใช้มาโครเพื่อทำให้ดูดีขึ้น :) ??? std_array = { …

137 c++  arrays  templates  initialization  c++11