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

ให้: #include <concepts> #include <iostream> template<class T> struct wrapper; template<std::signed_integral T> struct wrapper<T> { wrapper() = default; void print() { std::cout << "signed_integral" << std::endl; } }; template<std::integral T> struct wrapper<T> { wrapper() = default; void print() { std::cout << "integral" << std::endl; } }; int main() { wrapper<int> w; …

23 c++  language-lawyer  c++20  c++-concepts 

จากสิ่งที่ฉันรู้ขนาดของคลาสใน c ++ ขึ้นอยู่กับปัจจัยด้านล่าง - ขนาดของสมาชิกข้อมูลที่ไม่คงที่ทั้งหมด ลำดับของสมาชิกข้อมูล หากเปิดใช้งานการเสริมไบต์แล้วหรือไม่ ขนาดของคลาสฐานทันที การมีอยู่ของฟังก์ชั่นเสมือนจริง โหมดของการสืบทอด (การสืบทอดเสมือน) ตอนนี้ฉันได้สร้าง 2 ชั้นดังนี้ class A{ int a; short s; int b; char d; };// kept a char at last on purpose to leave a "hole" class B : public A{ char c; }; ตอนนี้ในการตรวจสอบขนาดของ A และ BI เห็น …

23 c++  inheritance  memory 

ฉันอ่านเกี่ยวกับฟังก์ชั่นเทมเพลตและสับสนกับปัญหานี้: #include <iostream> void f(int) { std::cout << "f(int)\n"; } template<typename T> void g(T val) { std::cout << typeid(val).name() << " "; f(val); } void f(double) { std::cout << "f(double)\n"; } template void g<double>(double); int main() { f(1.0); // f(double) f(1); // f(int) g(1.0); // d f(int), this is surprising …

23 c++  function-templates  name-lookup  dependent-name  unqualified-name 

ฉันพบว่าผลลัพธ์นั้นแตกต่างกันในคอมไพเลอร์ถ้าฉันใช้แลมบ์ดาเพื่อจับการอ้างอิงไปยังตัวแปรทั่วโลกด้วยคำสำคัญที่ไม่แน่นอนและปรับเปลี่ยนค่าในฟังก์ชั่นแลมบ์ดา #include <stdio.h> #include <functional> int n = 100; std::function<int()> f() { int &m = n; return [m] () mutable -> int { m += 123; return m; }; } int main() { int x = n; int y = f()(); int z = n; printf("%d %d %d\n", x, y, …

22 c++  c++11  lambda  language-lawyer 

C ++ 20 อนุญาตให้ใช้autoสำหรับประเภทพารามิเตอร์ฟังก์ชัน มันยังอนุญาตให้ใช้autoเป็นตัวยึดอาร์กิวเมนต์เทมเพลต (ไม่เหมือนกัน แต่ในจิตวิญญาณของเทมเพลต C ++ 17 <auto>ในทางใดทางหนึ่ง) สำหรับประเภทพารามิเตอร์ฟังก์ชันหรือไม่ ดังนั้นรหัสต่อไปนี้ก่อน C ++ 20: template<typename First, typename Second> void printPair(const std::pair<First, Second>& p) { std::cout << p.first << ", " << p.second; } สามารถเขียนเป็น: void printPair(const std::pair<auto, auto>& p) { std::cout << p.first << ", " << p.second; …

22 c++  templates  auto  c++20 

[basic.scope.pdecl] / 1ของร่างมาตรฐาน C ++ 20 มีตัวอย่าง (ไม่ใช่กฎเกณฑ์) ดังต่อไปนี้ในบันทึกย่อ (อ้างบางส่วนจากก่อนที่จะรวมคำขอดึง 3580ดูคำตอบสำหรับคำถามนี้): unsigned char x = x; [... ] x ถูกเตรียมใช้งานด้วยค่าของตัวเอง (ไม่ทราบแน่ชัด) สิ่งนี้มีพฤติกรรมที่ชัดเจนใน C ++ 20 หรือไม่ โดยทั่วไปการกำหนดค่าเริ่มต้นด้วยตนเองของแบบฟอร์มT x = x;จะมีพฤติกรรมที่ไม่ได้กำหนดโดยอาศัยคุณค่าของxการไม่ได้กำหนดค่าก่อนที่การเริ่มต้นจะเสร็จสมบูรณ์ การประเมินค่าที่ไม่ทราบแน่ชัดมักทำให้เกิดพฤติกรรมที่ไม่ได้กำหนด ( [basic.indent] / 2 ) แต่มีข้อยกเว้นเฉพาะใน[basic.indent] /2.3ที่อนุญาตให้เริ่มต้นunsigned charตัวแปรโดยตรงจากค่า lvalue unsigned charด้วยค่าที่ไม่ทราบแน่ชัด ) นี้เพียงอย่างเดียวไม่ดังนั้นจึงไม่ก่อให้เกิดพฤติกรรมที่ไม่ได้กำหนด แต่จะประเภทอื่น ๆTที่ไม่ได้รับการรับรองรูปแบบตัวอักษรหรือแคบเช่นstd::byte int x = x;ข้อควรพิจารณาเหล่านี้มีผลใน …

22 c++  initialization  language-lawyer  lifetime  c++20 

บอกว่าผมมีshared_ptrกับการจัดสรรที่กำหนดเองและ Deleter ที่กำหนดเอง ฉันไม่สามารถหาอะไรในมาตรฐานที่พูดถึงว่าควรเก็บ deleter ที่ไหน: ไม่ได้บอกว่าตัวจัดสรรแบบกำหนดเองจะถูกใช้สำหรับหน่วยความจำของ deleter และมันไม่ได้บอกว่ามันจะไม่เป็นเช่นนั้น สิ่งนี้ไม่ได้ระบุหรือฉันเพิ่งจะพลาดบางสิ่ง

22 c++  language-lawyer  c++17  shared-ptr  allocator 

มาจากพื้นหลังหลามส่วนใหญ่ฉันค่อนข้างลำบากกับการทำงานกับประเภทใน C ++ ฉันพยายามที่จะเริ่มต้นตัวแปรระดับผ่านหนึ่งในหลายตัวสร้างมากเกินไปที่ใช้ประเภทที่แตกต่างกันเป็นพารามิเตอร์ ฉันได้อ่านแล้วว่าการใช้autoคำหลักนั้นสามารถใช้สำหรับการประกาศอัตโนมัติของตัวแปรได้อย่างไรก็ตามในกรณีของฉันมันจะไม่ถูกกำหนดค่าเริ่มต้นจนกว่าจะเลือกคอนสตรัคเตอร์ แต่คอมไพเลอร์ไม่ได้มีความสุขเกี่ยวกับการไม่ valueinitialising class Token { public: auto value; Token(int ivalue) { value = ivalue; } Token(float fvalue) { value = fvalue; } Token(std::string svalue) { value = svalue; } void printValue() { std::cout << "The token value is: " << value << std::endl; } }; …

22 c++  constructor  initialization  overloading  auto 

ใน C ++ 20 แนวคิดของ POD ถูกคัดค้านเนื่องจากเป็นลักษณะประกอบที่ไม่มีความหมายว่าเป็นเรื่องไร้สาระและมีรูปแบบมาตรฐาน อย่างไรก็ตามคำจำกัดความของ PODในร่าง C ++ 20 นั้นไม่ตรงกับ "ทั้งเรื่องธรรมดาและเลย์เอาต์มาตรฐาน" มันเป็นจริง: คลาส POD เป็นคลาสที่มีทั้งคลาสที่ไม่สำคัญและคลาสเลย์เอาต์มาตรฐานและไม่มีสมาชิกข้อมูลที่ไม่ใช่แบบคงที่ประเภทคลาสที่ไม่ใช่ POD (หรืออาร์เรย์ดังกล่าว) ประเภท POD เป็นประเภทสเกลาร์, คลาส POD, อาร์เรย์ของประเภทดังกล่าวหรือรุ่นที่ผ่านการรับรอง cv ของหนึ่งในประเภทเหล่านี้ กล่าวอีกนัยหนึ่งไม่เพียง แต่จะเป็นประเภท POD ทั้งรูปแบบไม่สำคัญและรูปแบบมาตรฐาน แต่ก็มีรูปแบบซ้ำ ๆ ข้อกำหนดแบบเรียกซ้ำซ้อนนี้ซ้ำซ้อนหรือไม่ กล่าวอีกนัยหนึ่งถ้าประเภทมีทั้งแบบธรรมดาและแบบเลย์เอาต์มันจะเป็นแบบไม่สำคัญและแบบมาตรฐานแบบซ้ำ ๆ โดยอัตโนมัติหรือไม่? หากคำตอบคือ "ไม่" ดังนั้นตัวอย่างของเลย์เอาต์มาตรฐานประเภทเล็ก ๆ น้อย ๆ ที่ไม่ได้เป็น POD คืออะไร

22 c++  language-lawyer  c++20  standard-layout 

พิจารณา int main() { auto a = new int[0]; delete[] a; // So there's no memory leak } ระหว่างการคัดลอกเริ่มต้นและการลบคุณได้รับอนุญาตให้อ่านตัวชี้ที่a + 1? นอกจากนี้ไม่อนุญาตให้มีภาษาคอมไพเลอร์ชุดaไปnullptr?

21 c++  language-lawyer 

#include <optional> bool f() { std::optional<int> opt; return opt; } ไม่ได้รวบรวม: 'return': cannot convert from 'std::optional<int>' to 'bool' การอ้างอิงการให้คำปรึกษาฉันคิดว่าจะหาคำอธิบาย แต่ฉันอ่านมันควรจะโอเค การแปลงโดยนัยจะดำเนินการทุกครั้งที่มีการใช้นิพจน์ประเภท T1 บางประเภทในบริบทที่ไม่ยอมรับประเภทนั้น แต่ยอมรับประเภท T2 บางประเภท โดยเฉพาะอย่างยิ่ง: เมื่อนิพจน์ใช้เป็นอาร์กิวเมนต์เมื่อเรียกใช้ฟังก์ชันที่ประกาศด้วย T2 เป็นพารามิเตอร์ เมื่อนิพจน์ถูกใช้เป็นตัวถูกดำเนินการกับตัวดำเนินการที่คาดว่า T2 เมื่อเริ่มต้นวัตถุใหม่ประเภท T2 รวมถึงคำสั่ง return ในฟังก์ชั่นการคืนค่า T2 เมื่อการแสดงออกที่ใช้ในงบสวิทช์ (T2 เป็นประเภทที่สำคัญ); เมื่อนิพจน์ถูกใช้ในคำสั่ง if หรือลูป (T2 คือบูล)

21 c++  language-lawyer  c++17  implicit-conversion 

สมมติว่าคุณต้องการใช้<random>สิ่งอำนวยความสะดวกC ++ ในโปรแกรมที่ใช้งานจริง (สำหรับคำจำกัดความของ "การปฏิบัติ" บางข้อ จำกัด ที่นี่เป็นส่วนหนึ่งของคำถามนี้) คุณได้รับรหัสคร่าว ๆ เช่นนี้: int main(int argc, char **argv) { int seed = get_user_provided_seed_value(argc, argv); if (seed == 0) seed = std::random_device()(); ENGINE g(seed); // TODO: proper seeding? go_on_and_use(g); } คำถามของฉันคือคุณควรใช้แบบENGINEไหน ฉันเคยพูดเสมอstd::mt19937เพราะมันพิมพ์ได้อย่างรวดเร็วและมีการจดจำชื่อ แต่ทุกวันนี้ดูเหมือนว่าทุกคนกำลังพูดว่า Mersenne Twister นั้นหนักและแคชไม่เป็นมิตรและไม่ผ่านการทดสอบทางสถิติทั้งหมดที่คนอื่นทำ ฉันต้องการพูดstd::default_random_engineเพราะเป็น "ค่าเริ่มต้น" ที่ชัดเจน แต่ฉันไม่รู้ว่ามันแตกต่างจากแพลตฟอร์มหนึ่งไปอีกแพลตฟอร์มหรือไม่และฉันไม่รู้ว่ามันดีทางสถิติหรือไม่ เนื่องจากทุกคนอยู่บนแพลตฟอร์ม 64 บิตวันนี้อย่างน้อยเราควรจะใช้std::mt19937_64มากกว่าstd::mt19937หรือไม่ …

21 c++  c++11  random 

ทำไม gcc เติมทั้งอาร์เรย์ด้วยศูนย์แทนที่จะเป็นจำนวนเต็ม 96 เท่านั้นที่เหลือ? initializers ที่ไม่ใช่ศูนย์ทั้งหมดอยู่ที่จุดเริ่มต้นของอาร์เรย์ void *sink; void bar() { int a[100]{1,2,3,4}; sink = a; // a escapes the function asm("":::"memory"); // and compiler memory barrier // forces the compiler to materialize a[] in memory instead of optimizing away } MinGW8.1 และ gcc9.2 สร้าง asm เช่นนี้ ( Godbolt …

21 c++  gcc  assembly  x86  compiler-optimization 

ในรหัสต่อไปนี้ฉันจะทำให้บรรทัดที่มีความคิดเห็นทำงานในลักษณะเดียวกับบรรทัดที่อยู่เหนือบรรทัดได้อย่างไร Typeผมอยากจะทำให้มันเป็นโค้ดทั่วไปที่โทรคอนสตรัคที่เหมาะสมของแม่แบบ #include <string> #include <iostream> template <typename Type> struct Class { Type data; Class(Type data) : data(data) { } }; int main() { Class<std::string> a = std::string("abc"); // Class<std::string> b = "abc"; std::cout << a.data << std::endl; return 0; }

21 c++  class  c++11  templates  initialization 

ฉันเขียนรหัสต่อไปนี้ซึ่งใช้ในunique_ptr<Derived>ที่ที่unique_ptr<Base>คาดไว้ class Base { int i; public: Base( int i ) : i(i) {} int getI() const { return i; } }; class Derived : public Base { float f; public: Derived( int i, float f ) : Base(i), f(f) {} float getF() const { return f; } }; void …

21 c++  templates  inheritance  unique-ptr