เมื่อใดควรใช้ตัวเริ่มต้นที่ปิดด้วยปีกกา

ใน C ++ 11 เรามีไวยากรณ์ใหม่สำหรับการเริ่มต้นคลาสซึ่งทำให้เรามีความเป็นไปได้มากมายในการเริ่มต้นตัวแปร

{ // Example 1
  int b(1);
  int a{1};
  int c = 1;
  int d = {1};
}
{ // Example 2
  std::complex<double> b(3,4);
  std::complex<double> a{3,4};
  std::complex<double> c = {3,4};
  auto d = std::complex<double>(3,4);
  auto e = std::complex<double>{3,4};
}
{ // Example 3
  std::string a(3,'x');
  std::string b{3,'x'}; // oops
}
{ // Example 4
  std::function<int(int,int)> a(std::plus<int>());
  std::function<int(int,int)> b{std::plus<int>()};
}
{ // Example 5
  std::unique_ptr<int> a(new int(5));
  std::unique_ptr<int> b{new int(5)};
}
{ // Example 6
  std::locale::global(std::locale("")); // copied from 22.4.8.3
  std::locale::global(std::locale{""});
}
{ // Example 7
  std::default_random_engine a {}; // Stroustrup's FAQ
  std::default_random_engine b;
}
{ // Example 8
  duration<long> a = 5; // Stroustrup's FAQ too
  duration<long> b(5);
  duration<long> c {5};
}

สำหรับตัวแปรแต่ละตัวที่ฉันประกาศฉันต้องคิดว่าควรใช้ไวยากรณ์การเริ่มต้นตัวใดและสิ่งนี้ทำให้ความเร็วในการเข้ารหัสของฉันช้าลง ฉันแน่ใจว่านั่นไม่ใช่เจตนาที่จะแนะนำวงเล็บปีกกา

เมื่อพูดถึงรหัสเทมเพลตการเปลี่ยนไวยากรณ์อาจทำให้เกิดความหมายที่แตกต่างกันดังนั้นการไปในทางที่ถูกต้องจึงเป็นสิ่งสำคัญ

ฉันสงสัยว่ามีแนวทางสากลที่ควรเลือกไวยากรณ์หรือไม่

ฉันคิดว่าสิ่งต่อไปนี้อาจเป็นแนวทางที่ดี:

• หากค่า (ค่าเดียว) ที่คุณกำลังเริ่มต้นมีจุดมุ่งหมายเพื่อเป็นค่าที่แน่นอนของวัตถุให้ใช้การ=เริ่มต้นcopy ( ) (เนื่องจากในกรณีที่เกิดข้อผิดพลาดคุณจะไม่เรียกใช้ตัวสร้างที่ชัดเจนโดยไม่ได้ตั้งใจซึ่งโดยทั่วไปจะตีความค่าที่ระบุ แตกต่างกัน). ในสถานที่ที่ไม่มี copy initialization ให้ดูว่า brace initialization มีความหมายที่ถูกต้องหรือไม่และถ้าเป็นเช่นนั้นให้ใช้สิ่งนั้น มิฉะนั้นให้ใช้การเริ่มต้นในวงเล็บ (หากยังไม่พร้อมใช้งานคุณก็โชคไม่ดีอยู่ดี)

• หากค่าที่คุณกำลังเริ่มต้นเป็นรายการของค่าที่จะเก็บไว้ในออบเจ็กต์ (เช่นองค์ประกอบของเวกเตอร์ / อาร์เรย์หรือส่วนจริง / จินตภาพของจำนวนเชิงซ้อน) ให้ใช้การเริ่มต้นวงเล็บปีกกาถ้ามี

• หากค่าที่คุณกำลังเตรียมใช้งานไม่ใช่ค่าที่จะจัดเก็บ แต่อธิบายถึงค่า / สถานะของวัตถุที่ต้องการให้ใช้วงเล็บ ตัวอย่างคืออาร์กิวเมนต์ขนาดของ a vectorหรืออาร์กิวเมนต์ชื่อไฟล์ของไฟล์fstream.

ฉันค่อนข้างมั่นใจว่าจะไม่มีแนวทางสากล วิธีการของฉันคือใช้วงเล็บปีกกาจำไว้เสมอ

1. ตัวสร้างรายการตัวเริ่มต้นมีความสำคัญเหนือตัวสร้างอื่น ๆ
2. คอนเทนเนอร์ไลบรารีมาตรฐานและ std :: basic_string ทั้งหมดมีตัวสร้างรายการตัวเริ่มต้น
3. การเริ่มต้น Curly brace ไม่อนุญาตให้ จำกัด การแปลง

เครื่องมือจัดฟันแบบกลมและแบบลอนจึงไม่สามารถใช้แทนกันได้ แต่การรู้ว่าพวกเขาแตกต่างกันตรงไหนทำให้ฉันสามารถใช้การกำหนดค่าเริ่มต้นของวงเล็บเหลี่ยมแบบโค้งได้ในกรณีส่วนใหญ่ (บางกรณีที่ฉันไม่สามารถเป็นบั๊กของคอมไพเลอร์ได้ในขณะนี้)

ด้านนอกของรหัสทั่วไป (เช่นแม่แบบ) คุณสามารถ (และฉันจะทำ) ใช้การจัดฟันได้ทุกที่ ข้อดีอย่างหนึ่งคือมันทำงานได้ทุกที่เช่นแม้กระทั่งการเริ่มต้นในคลาส:

struct foo {
    // Ok
    std::string a = { "foo" };

    // Also ok
    std::string b { "bar" };

    // Not possible
    std::string c("qux");

    // For completeness this is possible
    std::string d = "baz";
};

หรือสำหรับอาร์กิวเมนต์ของฟังก์ชัน:

void foo(std::pair<int, double*>);
foo({ 42, nullptr });
// Not possible with parentheses without spelling out the type:
foo(std::pair<int, double*>(42, nullptr));

สำหรับตัวแปรที่ฉันไม่ได้ให้ความสนใจมากนักระหว่างรูปแบบT t = { init };หรือT t { init };ฉันพบว่าความแตกต่างเป็นเพียงเล็กน้อยและอย่างแย่ที่สุดก็จะส่งผลให้มีข้อความคอมไพเลอร์ที่เป็นประโยชน์เกี่ยวกับการใช้ตัวexplicitสร้างในทางที่ผิด

สำหรับประเภทที่ยอมรับstd::initializer_listแม้ว่าจะเห็นได้ชัดว่าบางครั้งไม่std::initializer_listจำเป็นต้องใช้ตัวสร้าง (ตัวอย่างคลาสสิกคือstd::vector<int> twenty_answers(20, 42);) ไม่ต้องใช้เครื่องมือจัดฟันแล้ว

เมื่อพูดถึงรหัสทั่วไป (เช่นในเทมเพลต) ย่อหน้าสุดท้ายควรมีคำเตือนบางอย่าง พิจารณาสิ่งต่อไปนี้:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{ return std::unique_ptr<T> { new T { std::forward<Args>(args)... } }; }

จากนั้นauto p = make_unique<std::vector<T>>(20, T {});สร้างเวกเตอร์ขนาด 2 ถ้าTเป็นเช่นintหรือเวกเตอร์ขนาด 20 ถ้าเป็นT std::stringสัญญาณที่บอกได้ชัดเจนว่ามีบางอย่างผิดปกติเกิดขึ้นที่นี่คือไม่มีลักษณะใดที่สามารถช่วยคุณได้ที่นี่ (เช่นกับ SFINAE): std::is_constructibleเป็นในแง่ของการเริ่มต้นโดยตรงในขณะที่เราใช้การเริ่มต้นด้วยรั้งซึ่งเลื่อนไปตรง - การเริ่มต้นในกรณีที่ไม่มีตัวสร้างที่std::initializer_listรบกวน ในทำนองเดียวกันstd::is_convertibleไม่มีความช่วยเหลือ

ฉันได้ตรวจสอบแล้วว่าเป็นไปได้หรือไม่ที่จะม้วนลักษณะที่สามารถแก้ไขได้ แต่ฉันไม่ได้มองโลกในแง่ดีเกินไป ไม่ว่าในกรณีใดฉันไม่คิดว่าเราจะพลาดอะไรไปมากฉันคิดว่าความจริงที่ว่าmake_unique<T>(foo, bar)ผลลัพธ์ในการก่อสร้างเทียบเท่าT(foo, bar)นั้นใช้งานง่ายมาก โดยเฉพาะอย่างยิ่งที่make_unique<T>({ foo, bar })เป็นที่แตกต่างกันมากและมี แต่จะทำให้รู้สึกว่าfooและbarมีชนิดเดียวกัน

ดังนั้นสำหรับรหัสทั่วไปฉันเท่านั้นที่ใช้สำหรับการจัดฟันเริ่มต้นค่า (เช่นT t {};หรือT t = {};) ซึ่งมีความสะดวกมากและฉันคิดว่าดีกว่าไปที่ C ++ 03 T t = T();วิธี มิฉะนั้นจะเป็นไวยากรณ์การเริ่มต้นโดยตรง (เช่นT t(a0, a1, a2);) หรือบางครั้งโครงสร้างเริ่มต้น ( T t; stream >> t;เป็นกรณีเดียวที่ฉันคิดว่าฉันใช้)

นั่นไม่ได้หมายความว่าการจัดฟันทั้งหมดจะไม่ดีให้พิจารณาตัวอย่างก่อนหน้านี้ด้วยการแก้ไข:

template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{ return std::unique_ptr<T> { new T(std::forward<Args>(args)...) }; }

นี้ยังคงใช้เครื่องหมายวงเล็บสำหรับสร้างแม้ว่าชนิดที่เกิดขึ้นจริงขึ้นอยู่กับพารามิเตอร์แม่แบบstd::unique_ptr<T>T