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

ในการพูดคุยล่าสุดของเขา“ชนิดเล่นสำนวนในปัจจุบัน c ++”มู Doumler กล่าวว่าstd::bit_castไม่สามารถนำมาใช้เพื่อบิตโยนfloatลงไปunsigned char[4]เพราะอาร์เรย์แบบ C ไม่สามารถกลับมาจากฟังก์ชั่น เราควรใช้std::memcpyหรือรอจนกว่า C ++ 23 (หรือหลังจากนั้น) เมื่อสิ่งที่ชอบreinterpret_cast<unsigned char*>(&f)[i]จะกลายเป็นชัดเจน ใน C ++ 20 เราสามารถใช้std::arrayกับstd::bit_cast, float f = /* some value */; auto bits = std::bit_cast<std::array<unsigned char, sizeof(float)>>(f); แทนที่จะเป็นอาร์เรย์แบบ C เพื่อรับจำนวนไบต์float?

14 c++  c++20  type-punning 

ฉันพยายามที่จะเข้าใจประเภทการแสดงออกของ C ++ และยิ่งฉันอ่านยิ่งฉันสับสนมากขึ้นเนื่องจากฉันพบว่า C ++ ร่างยากมากที่จะแยกย่อยและดังนั้นจึงชอบแหล่งข้อมูลอื่น แต่พวกเขาขัดแย้งกันหรือไม่คำนึงว่า ถ้อยคำและคำจำกัดความระหว่างเวอร์ชัน C ++ มีการเปลี่ยนแปลงอย่างมาก ในต่อไปนี้ฉันหมายถึงร่างต่อไปนี้: C ++ 11 [ n3690 ] (ร่างสุดท้าย) C ++ 17 [ n4659 ] (ร่างสุดท้าย) C ++ 20 [ n4835 ] (ร่างปัจจุบัน) C++11 3.10 ค่าและค่า ... prvalue (“ pure” rvalue) คือ rvalue ที่ไม่ใช่ xvalue [ตัวอย่าง: ผลลัพธ์ของการเรียกฟังก์ชั่นที่มีประเภทส่งคืนไม่ใช่การอ้างอิงคือ prvalue ค่าของตัวอักษรเช่น …

13 c++  c++11  c++14  c++17  c++20 

แนวคิดequality_­comparable_with<T, U>มีจุดมุ่งหมายที่จะประกาศวัตถุชนิดที่TและUสามารถนำมาเปรียบเทียบเท่ากับแต่ละอื่น ๆ และถ้าพวกเขาอยู่แล้วนี้มีความหมายที่คาดหวัง ไม่เป็นไร. อย่างไรก็ตามแนวคิดนี้ยังต้องcommon_reference_t<T&, U&>มีอยู่ แรงกระตุ้นหลักสำหรับcommon_referenceและฟังก์ชั่นการดูแลของมันดูเหมือนว่าจะเปิดใช้งานตัวทำซ้ำพร็อกซีเพื่อให้มีสถานที่ที่จะเป็นตัวแทนของความสัมพันธ์ระหว่างreferenceและvalue_typeสำหรับการทำซ้ำดังกล่าว เยี่ยมมาก แต่ ... สิ่งใดที่เกี่ยวข้องกับการทดสอบว่า a Tและ a Uสามารถเปรียบเทียบกันได้หรือไม่ ทำไมมาตรฐานจึงต้องการสิ่งนั้นTและUมีความสัมพันธ์อ้างอิงร่วมกันเพียงเพื่อให้คุณสามารถเปรียบเทียบพวกเขาได้เท่ากัน? สิ่งนี้จะสร้างสถานการณ์คี่บอลซึ่งเป็นการยากมากที่จะมีสองประเภทซึ่งไม่มีเหตุผลพอสมควรที่มีความสัมพันธ์อ้างอิงทั่วไปที่เทียบเคียงได้ในเชิงตรรกะ ตัวอย่างเช่นvector<int>และpmr::vector<int>เหตุผลควรเปรียบเทียบ แต่ไม่สามารถทำได้เพราะไม่มีการอ้างอิงทั่วไปที่สมเหตุสมผลระหว่างสองประเภทที่ไม่เกี่ยวข้องกัน

12 c++  c++20  c++-concepts 

จนถึงมาตรฐาน C ++ 20 ของ C ++ เมื่อเราต้องการกำหนดโอเปอเรเตอร์นอกคลาสซึ่งใช้สมาชิกส่วนตัวของคลาสเทมเพลตเราจะใช้โครงสร้างที่คล้ายกับสิ่งนี้: template <typename T> class Foo; template <typename T> constexpr bool operator==(T lhs, const Foo<T>& rhs); template <typename T> class Foo { public: constexpr Foo(T k) : mK(k) {} constexpr friend bool operator==<T>(T lhs, const Foo& rhs); private: T mK; }; template <typename …

12 c++  templates  c++20 

ฉันกำลังค้นหาวิธีที่จะระบุ lambdas ที่ว่างเปล่า (ไม่มีขอบเขต) จาก lambdas อื่น ๆ ในฟังก์ชั่นเทมเพลต ปัจจุบันฉันใช้ C ++ 17 แต่ฉันอยากรู้คำตอบ C ++ 20 ด้วย รหัสของฉันมีลักษณะเช่นนี้: template<typename T> auto func(T lambda) { // The aguments of the lambdas are unknown if constexpr (/* is captureless */) { // do stuff } } มันรับประกันโดยมาตรฐาน C ++ (17 หรือ …

12 c++  lambda  c++17  c++20 

พิจารณาสามstructs ต่อไปนี้: class blub { int i; char c; blub(const blub&) {} }; class blob { char s; blob(const blob&) {} }; struct bla { blub b0; blob b1; }; บนแพลตฟอร์มทั่วไปที่intมีขนาด 4 ไบต์ขนาดการจัดตำแหน่งและระยะห่างรวม1เป็นดังนี้: struct size alignment padding -------- ------ ----------- --------- blub 8 4 3 blob 1 1 0 bla …

12 c++  language-lawyer  c++20 

เราอยู่ในปี 2020 และ C ++ 20 กำลังจะมาพร้อมกับคุณสมบัติโมดูล C ++ ที่รอคอยมานาน แต่หลังจากดูการพูดคุยกับ CppCon ไม่กี่ครั้งฉันพบว่าโมดูล C ++ อยู่ในสถานที่แปลก ๆ โดยเฉพาะอย่างยิ่งสำหรับผู้จัดการแพ็คเกจ Linux (pacman, apt, โผล่ออกมา ฯลฯ ) จากสิ่งที่ฉันได้เรียนรู้โมดูล C ++ คือ คอมไพเลอร์ขึ้นอยู่กับ คุณไม่สามารถใช้โมดูลที่สร้างโดย GCC ใน Clang โมดูล GCC 9.1 จะไม่ทำงานบน GCC 9.2 คุณสามารถมีโมดูลเดียวกันหลายรุ่น ตราบใดที่ยังไม่ถูกส่งออกไปยังขอบเขตเดียวกัน คุณต้องสร้างโมดูลขึ้นใหม่หากการพึ่งพาของมันอัพเดต ปัญหาของฉันคือในการรวบรวม distros คอมไพเลอร์ทั้งหมดได้รับการปรับปรุงตลอดเวลาและผู้ใช้อาจมีการสร้างคอมไพเลอร์ของตัวเอง ในปัจจุบันสามารถอัพเดตคอมไพเลอร์หรืออัพเดตlibstdc++ได้ แต่ด้วยโมดูลดูเหมือนว่าจะแนะนำให้libstdc++มีการปรับปรุงเมื่อคอมไพเลอร์ปรับปรุง ตัวจัดการแพ็กเกจจะจัดการกับการอัพเดตอย่างไรเช่น STL เมื่อคอมไพเลอร์อัพเดต …

12 c++  dependency-management  c++20  package-management  c++-modules 

เนื่องจากแนวคิดถูกกำหนดให้เป็นเพรดิเคตเวลาคอมไพล์จึงเป็นไปได้หรือไม่ที่จะใช้เพรดิเคตเหล่านี้ซ้ำสำหรับอัลกอริธึมเวลารวบรวม เช่นเป็นไปได้ไหมที่จะตรวจสอบว่าทุกประเภทใน tuple สอดคล้องกับแนวคิดหรือไม่? เท่าที่ฉันได้เห็นมันเป็นไปไม่ได้ที่จะส่งแนวคิดไปยังฟังก์ชั่นในทางใดทางหนึ่งซึ่งทำให้ฉันกลับไปใช้แม่แบบสำหรับกรณีเหล่านี้ #include <type_traits> template<typename T> concept FloatLike = std::is_same_v<T, float>; struct IsFloat { template<typename U> constexpr static bool test() { return FloatLike<U>; } }; template<typename Predicate, typename... T> constexpr bool all_types() { return (Predicate::template test<T>() && ...); } int main() { static_assert(all_types<IsFloat, float, float>()); static_assert(!all_types<IsFloat, float, …

12 c++  templates  template-meta-programming  c++20  concept 

คำถามนี้หมายถึงการเพิ่มP0593ให้กับC ++ 20 ฉบับร่างล่าสุด นี่คือตัวอย่างของฉัน: #include <cstdlib> #include <cstdio> void foo(void *p) { if ( std::getchar() == 'i' ) { *(int *)p = 2; std::printf("%d\n", *(int *)p); } else { *(float *)p = 2; std::printf("%f\n", *(float *)p); } } int main() { void *a = std::malloc( sizeof(int) + sizeof(float) ); …

11 c++  language-lawyer  c++20 

รหัสต่อไปนี้รวบรวมดีกับ clang-trunk ในโหมด c ++ 17 แต่แบ่งในโหมด c ++ 2a (c ++ 20 ที่กำลังมาถึง): // Meta struct describing the result of a comparison struct Meta {}; struct Foo { Meta operator==(const Foo&) {return Meta{};} Meta operator!=(const Foo&) {return Meta{};} }; int main() { Meta res = (Foo{} != Foo{}); } …

11 c++  language-lawyer  eigen  eigen3  c++20 

Constructor ของ std :: span ทั้งหมดได้รับการประกาศให้เป็น constexpr แต่ฉันไม่สามารถทำให้พวกมันทำงานในบริบทของ constexpr ได้ การไม่แสดงข้อคิดเห็น constexpr ด้านล่างใด ๆ จะส่งผลให้เกิดข้อผิดพลาดในการรวบรวม #include <array> #include <span> int main() { constexpr int carray[3] = { 0, 1, 2 }; constexpr std::array<int, 3> array{ 0, 1, 2 }; using S = std::span<const int, 3>; /*constexpr*/ S span1{ array.data(), 3 …

11 c++  constexpr  c++20 

ใน C ++ 20 มาตรฐานมันก็บอกว่าประเภทอาร์เรย์เป็นประเภทอายุการใช้งานโดยปริยาย หมายความว่าอาเรย์สำหรับประเภทอายุการใช้งานที่ไม่แน่นอนสามารถสร้างได้หรือไม่? การสร้างอาเรย์โดยนัยจะไม่ทำให้เกิดการสร้างองค์ประกอบของอาเรย์? พิจารณากรณีนี้: //implicit creation of an array of std::string //but not the std::string elements: void * ptr = operator new(sizeof (std::string) * 10); //use launder to get a "pointer to object" (which object?) std::string * sptr = std::launder(static_cast<std::string*>(ptr)); //pointer arithmetic on not created array …

10 c++  arrays  dynamic-arrays  lifetime  c++20 

การstd::spanออกแบบที่ไม่ได้เป็นการอ้างอิงที่มีน้ำหนักเบาไปยัง sub-region ของstd::vector/ std::array/ array แบบธรรมดาหรือไม่? มันควรจะมีตัวดำเนินการเปรียบเทียบใน API ของมันหรือไม่เพื่อให้สอดคล้องกับพวกเขา อะไรคือเหตุผลเบื้องหลังการยกเว้น หมายเหตุ: โดยผู้ประกอบการเปรียบเทียบผมหมายถึงทั้งชุดเต็ม ( <, <=, ... ) หรือยานอวกาศ<=>

10 c++  std  c++20  std-span 

ช่วงกำลังมาถึง C ++ ด้วยเวอร์ชันมาตรฐาน C ++ 20 คำถามของฉัน: เราจะสามารถสร้างคอนเทนเนอร์ไลบรารีมาตรฐาน (ปัจจุบัน) กับช่วงใด ๆ ได้หรือไม่ และที่สำคัญยิ่งกว่าด้วยมุมมองระยะไกล? ตัวอย่างเช่นจะ: #include <vector> #include <iostream> #include <ranges> int main() { auto sq = [](int x) { return x * x; }; std::vector<int> vec { 3, 4, 5 }; std::vector<int> squares { std::ranges::views::transform(vec, sq) }; for(auto i …

10 c++  c++20  range-v3 

ในตัวอย่างต่อไปนี้อาร์กิวเมนต์ของฟังก์ชันถูกใช้เพื่อทดสอบด้วยนิพจน์ที่ต้องการว่านิพจน์ที่ใช้พวกเขานั้นมีรูปแบบที่ดีหรือไม่ การแสดงออกต้องไม่มีการโต้แย้ง; มันใช้ตัวแปรในขอบเขตฟังก์ชั่นโดยตรง: #include <cstddef> #include <vector> template<typename T> void Resize(T &v, std::size_t const n) { if constexpr (requires { v.resize(n); }) v.resize(n); } template<typename T> void Eziser(T &v, std::size_t const n) { if constexpr (requires { v.eziser(n); }) v.eziser(n); } int main() { std::vector<int> v; Resize(v, 10u); Eziser(v, 10u); …

10 c++  c++20  c++-concepts