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

ถ้าคุณอ่านรหัสเช่น auto&& var = foo(); ซึ่งfooเป็นฟังก์ชั่นใด ๆ Tกลับมาจากค่าของชนิด จากนั้นvarเป็น lvalue อ้างอิงประเภท rvalue Tไป แต่สิ่งนี้บ่งบอกถึงvarอะไร? หมายความว่าเราได้รับอนุญาตให้ขโมยทรัพยากรของvarหรือไม่ มีสถานการณ์ที่เหมาะสมเมื่อคุณควรใช้auto&&เพื่อบอกผู้อ่านโค้ดของคุณว่าคุณทำอย่างไรเมื่อคุณกลับมาunique_ptr<>เพื่อบอกว่าคุณมีความเป็นเจ้าของโดยเฉพาะ? และตัวอย่างเช่นT&&เมื่อTเป็นประเภทชั้นเรียน? ฉันแค่ต้องการที่จะเข้าใจหากมีกรณีการใช้งานอื่น ๆ ที่auto&&นอกเหนือจากในการเขียนโปรแกรมแม่แบบ; เหมือนที่กล่าวไว้ในตัวอย่างในบทความนี้Universal Referencesโดย Scott Meyers

168 c++  c++11  auto  forwarding-reference 

ชื่อค่อนข้างสื่อความหมายได้เอง ฉันดาวน์โหลด Qt Creator 2.7.0 แล้วและฉันพยายามรวบรวมรหัส C ++ 11 พื้นฐาน: int my_array[5] = {1, 2, 3, 4, 5}; for(int &x : my_array) { x *= 2; } ฉันได้รับข้อผิดพลาดต่อไปนี้: range based for loops are not allowed in c++ 98 mode แต่ตามบทความนี้ผู้สร้าง Qt รุ่นนี้รองรับ C ++ 11 ดังนั้นฉันจะเปิดใช้งานได้อย่างไร

167 c++  qt  c++11 

มันเป็นไปได้ที่จะจับโดยอ้างอิง const ในการแสดงออกแลมบ์ดา? ฉันต้องการให้การบ้านที่ระบุไว้ด้านล่างล้มเหลวตัวอย่างเช่น: #include <cstdlib> #include <vector> #include <string> #include <algorithm> using namespace std; int main() { string strings[] = { "hello", "world" }; static const size_t num_strings = sizeof(strings)/sizeof(strings[0]); string best_string = "foo"; for_each( &strings[0], &strings[num_strings], [&best_string](const string& s) { best_string = s; // this should fail } …

166 c++  c++11  lambda  c++14 

Scott Meyers โพสต์เนื้อหาและสถานะของหนังสือเล่มต่อไปของเขา EC ++ 11 เขาเขียนว่าหนึ่งรายการในหนังสือเล่มนี้อาจจะ"หลีกเลี่ยงการstd::enable_ifอยู่ในลายเซ็นฟังก์ชั่น" std::enable_if สามารถใช้เป็นอาร์กิวเมนต์ฟังก์ชั่นเป็นประเภทผลตอบแทนหรือเป็นแม่แบบชั้นเรียนหรือพารามิเตอร์แม่แบบฟังก์ชั่นเพื่อลบฟังก์ชั่นหรือคลาสจากเงื่อนไขการแก้ไขเกินพิกัด ในคำถามนี้จะแสดงคำตอบทั้งสาม พารามิเตอร์ฟังก์ชั่น: template<typename T> struct Check1 { template<typename U = T> U read(typename std::enable_if< std::is_same<U, int>::value >::type* = 0) { return 42; } template<typename U = T> U read(typename std::enable_if< std::is_same<U, double>::value >::type* = 0) { return 3.14; } }; เป็นพารามิเตอร์เทมเพลต: …

165 c++  templates  c++11  sfinae  enable-if 

#include <iostream> struct a { enum LOCAL_A { A1, A2 }; }; enum class b { B1, B2 }; int foo(int input) { return input; } int main(void) { std::cout << foo(a::A1) << std::endl; std::cout << foo(static_cast<int>(b::B2)) << std::endl; } นี่a::LOCAL_Aคือสิ่งที่ enum ที่พิมพ์อย่างรุนแรงพยายามที่จะบรรลุ แต่มีความแตกต่างเล็กน้อย: enums ปกติสามารถแปลงเป็นประเภทจำนวนเต็มได้ในขณะที่ enums ที่พิมพ์อย่างรุนแรงไม่สามารถทำได้โดยไม่ต้องใช้นักแสดง ดังนั้นมีวิธีการแปลงค่า enum …

165 c++  c++11  strongly-typed-enum 

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

164 c++  c++11  c++03 

ชิ้นส่วนของรหัสนี้แนวคิดจะเป็นสิ่งเดียวกันสำหรับสามตัวชี้ (เริ่มต้นชี้ปลอดภัย): int* p1 = nullptr; int* p2 = NULL; int* p3 = 0; ดังนั้นสิ่งที่เป็นข้อดีของการกำหนดตัวชี้nullptrมากกว่ากำหนดให้ค่าNULLหรือ0?

163 c++  c++11  null  c++-faq  nullptr 

มาตรฐาน C ++ 11 (ISO / IEC 14882: 2011) กล่าวใน§ C.1.1: char* p = "abc"; // valid in C, invalid in C++ สำหรับ C ++ มันก็โอเคในฐานะที่เป็นตัวชี้ไปที่ตัวอักษรของสตริงที่เป็นอันตรายเนื่องจากความพยายามใด ๆ ในการแก้ไขมันจะนำไปสู่ความผิดพลาด แต่ทำไมมันถึงใช้ได้ใน C? C ++ 11 ยังบอกด้วย: char* p = (char*)"abc"; // OK: cast added ซึ่งหมายความว่าหากมีการเพิ่มการร่ายลงในคำสั่งแรกมันจะใช้ได้ ทำไมการคัดเลือกนักแสดงทำให้คำสั่งที่สองใช้ได้ใน C ++ และมันแตกต่างจากคำสั่งแรกได้อย่างไร? มันยังคงเป็นอันตรายหรือไม่? ถ้าเป็นเช่นนั้นทำไมมาตรฐานถึงบอกว่าตกลง

163 c++  c  string  c++11  char 

ขอบคุณ C ++ 11 ที่เราได้รับการstd::functionห่อหุ้มของ functor น่าเสียดายที่ฉันได้ยิน แต่เรื่องเลวร้ายเกี่ยวกับการเพิ่มสิ่งใหม่เหล่านี้เท่านั้น ความนิยมมากที่สุดคือพวกเขาช้าอย่างน่ากลัว ฉันทดสอบมันและพวกเขาดูดอย่างแท้จริงเมื่อเปรียบเทียบกับแม่แบบ #include <iostream> #include <functional> #include <string> #include <chrono> template <typename F> float calc1(F f) { return -1.0f * f(3.3f) + 666.0f; } float calc2(std::function<float(float)> f) { return -1.0f * f(3.3f) + 666.0f; } int main() { using namespace std::chrono; const …

161 c++  templates  c++11  std-function 

ฉันเห็นสิ่งนี้ที่นี่: Move Constructor โทรหา Move Constructor ระดับฐาน มีคนอธิบายได้ไหม: ความแตกต่างระหว่างstd::moveและstd::forwardโดยเฉพาะอย่างยิ่งกับตัวอย่างรหัสบางอย่าง? วิธีคิดเกี่ยวกับมันง่าย ๆ และเมื่อใดควรใช้แบบไหน

160 c++  c++11  perfect-forwarding 

ฉันมีปัญหาในการทำความเข้าใจการใช้งานตัวชี้อัจฉริยะในฐานะสมาชิกคลาสใน C ++ 11 ฉันได้อ่านพอยน์เตอร์ที่ชาญฉลาดมากและฉันคิดว่าฉันเข้าใจวิธีการunique_ptrและshared_ptr/ หรือweak_ptrทำงานโดยทั่วไป สิ่งที่ฉันไม่เข้าใจคือการใช้งานจริง ดูเหมือนว่าทุกคนแนะนำให้ใช้unique_ptrเป็นวิธีที่จะไปเกือบตลอดเวลา แต่ฉันจะใช้บางสิ่งเช่นนี้ได้อย่างไร: class Device { }; class Settings { Device *device; public: Settings(Device *device) { this->device = device; } Device *getDevice() { return device; } }; int main() { Device *device = new Device(); Settings settings(device); // ... Device *myDevice = settings.getDevice(); // …

159 c++  c++11  shared-ptr  smart-pointers  unique-ptr 

ทำไมฉันจึงควรเลือกอย่างใดอย่างหนึ่งในทางปฏิบัติ อะไรคือความแตกต่างทางเทคนิคยกเว้นstd::threadชั้นเรียน

157 c++  multithreading  c++11  pthreads 

ฉันจะจับภาพด้วยการย้าย (หรือที่รู้จักกันว่าการอ้างอิง rvalue) ในแลมบ์ดา C ++ 11 ได้อย่างไร ฉันกำลังพยายามเขียนสิ่งนี้: std::unique_ptr<int> myPointer(new int); std::function<void(void)> example = [std::move(myPointer)]{ *myPointer = 4; };

157 c++  lambda  c++11  rvalue-reference 

std::enable_ifฉันพยายามที่จะได้รับตัวอย่างง่ายๆในการทำงานจะเข้าใจวิธีการใช้งาน หลังจากที่ฉันอ่านคำตอบนี้ฉันคิดว่ามันไม่ควรยากเกินไปที่จะเกิดขึ้นกับตัวอย่างง่ายๆ ฉันต้องการใช้std::enable_ifเพื่อเลือกระหว่างสองฟังก์ชั่นสมาชิกและอนุญาตให้ใช้หนึ่งในนั้นเท่านั้น น่าเสียดายที่สิ่งต่อไปนี้ไม่ได้รวบรวมกับ gcc 4.7 และหลังจากเวลาผ่านไปหลายชั่วโมงของการลองฉันถามพวกคุณว่าสิ่งที่ฉันผิดคืออะไร #include <utility> #include <iostream> template< class T > class Y { public: template < typename = typename std::enable_if< true >::type > T foo() { return 10; } template < typename = typename std::enable_if< false >::type > T foo() { return 10; } }; …

156 c++  templates  g++  c++11 

C ++ 0x แสดงตัวอย่างการใช้std::forward: template<class T> void foo(T&& arg) { bar(std::forward<T>(arg)); } เมื่อใดจึงจะใช้ประโยชน์std::forwardเสมอ นอกจากนี้ยังจำเป็นต้องใช้&&ในการประกาศพารามิเตอร์มันถูกต้องในทุกกรณี? ฉันคิดว่าคุณจะต้องส่งผ่านฟังก์ชั่นชั่วคราวหากฟังก์ชั่นนั้นถูกประกาศไว้&&ในนั้นดังนั้นฟูสามารถถูกเรียกด้วยพารามิเตอร์ใด ๆ ได้หรือไม่? สุดท้ายถ้าฉันมีฟังก์ชั่นการโทรเช่นนี้ template<int val, typename... Params> void doSomething(Params... args) { doSomethingElse<val, Params...>(args...); } ฉันควรใช้สิ่งนี้แทน: template<int val, typename... Params> void doSomething(Params&&... args) { doSomethingElse<val, Params...>(std::forward<Params>(args)...); } นอกจากนี้หากใช้พารามิเตอร์สองครั้งในฟังก์ชั่นเช่นการส่งต่อไปยังสองฟังก์ชั่นในเวลาเดียวกันควรใช้std::forwardหรือไม่? จะไม่std::forwardแปลงสิ่งเดียวกันเป็นสองครั้งชั่วคราวย้ายหน่วยความจำและทำให้ไม่ถูกต้องสำหรับการใช้งานครั้งที่สอง? รหัสต่อไปนี้จะโอเคไหม template<int val, typename... Params> void doSomething(Params&&... …

155 c++  templates  forwarding  c++11