คำหลักอัตโนมัติ C ++ 11 มีมากเกินไป

ฉันใช้autoคำหลักใหม่ที่มีอยู่ในมาตรฐาน C ++ 11 สำหรับประเภท templated ที่ซับซ้อนซึ่งเป็นสิ่งที่ฉันเชื่อว่าได้รับการออกแบบมา แต่ฉันก็ใช้มันเพื่อสิ่งต่าง ๆ เช่น:

auto foo = std::make_shared<Foo>();

และน่าสงสัยมากขึ้นสำหรับ:

auto foo = bla(); // where bla() return a shared_ptr<Foo>

ฉันไม่เห็นการสนทนาในหัวข้อนี้มากนัก ดูเหมือนว่าautoจะใช้มากเกินไปเนื่องจากประเภทหนึ่งมักเป็นรูปแบบของเอกสารและการตรวจสอบสติ คุณวาดเส้นในการใช้ที่ไหนautoและกรณีการใช้งานที่แนะนำสำหรับคุณลักษณะใหม่นี้คืออะไร

เพื่อชี้แจง: ฉันไม่ได้ขอความคิดเห็นทางปรัชญา; ฉันขอใช้คำหลักนี้อย่างตั้งใจโดยคณะกรรมการมาตรฐานอาจมีความคิดเห็นเกี่ยวกับวิธีการใช้งานที่ตั้งใจนั้นได้รับรู้ในทางปฏิบัติ

หมายเหตุด้านข้าง: คำถามนี้ถูกย้ายไปที่ SE.Programmers แล้วกลับไปที่ Stack Overflow การสนทนาเกี่ยวกับเรื่องนี้สามารถพบได้ในคำถามเมตานี้

ฉันคิดว่าควรใช้autoคำหลักทุกครั้งที่ยากที่จะพูดวิธีเขียนประเภทตั้งแต่แรกเห็น แต่ประเภทของการแสดงออกทางขวามือนั้นชัดเจน ตัวอย่างเช่นการใช้:

my_multi_type::nth_index<2>::type::key_type::composite_key_type::
    key_extractor_tuple::tail_type::head_type::result_type

ที่จะได้รับชนิดที่สำคัญในคอมโพสิตแม้ว่าคุณจะรู้ว่ามันเป็นboost::multi_index intคุณไม่สามารถเขียนได้intเพราะอาจเปลี่ยนแปลงได้ในอนาคต ฉันจะเขียนautoในกรณีนี้

ดังนั้นหากautoคำหลักช่วยเพิ่มความสามารถในการอ่านในบางกรณีให้ใช้คำหลักนั้น คุณสามารถเขียนได้autoเมื่อผู้อ่านเห็นได้ชัดว่าประเภทautoใด

นี่คือตัวอย่างบางส่วน:

auto foo = std::make_shared<Foo>();   // obvious
auto foo = bla();                     // unclear. don't know which type `foo` has

const size_t max_size = 100;
for ( auto x = max_size; x > 0; --x ) // unclear. could lead to the errors
                                      // since max_size is unsigned

std::vector<some_class> v;
for ( auto it = v.begin(); it != v.end(); ++it )
                                      // ok, since I know that `it` has an iterator type
                                      // (don't really care which one in this context)

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

ง่าย. ใช้มันเมื่อคุณไม่สนใจประเภทนั้น ตัวอย่างเช่น

for (const auto & i : some_container) {
   ...

ทั้งหมดที่ฉันสนใจนี่iคือสิ่งที่อยู่ในภาชนะ

มันเป็นเหมือน typedefs

typedef float Height;
typedef double Weight;
//....
Height h;
Weight w;

นี่ผมไม่สนใจว่าhและwมีลอยหรือคู่เท่านั้นที่พวกเขามีสิ่งที่ประเภทเหมาะที่จะแสดงความสูงและน้ำหนัก

หรือพิจารณา

for (auto i = some_container .begin (); ...

นี่คือทั้งหมดที่ฉันสนใจคือมันเป็นตัววนซ้ำที่เหมาะสมสนับสนุนoperator++()มันเหมือนกับเป็ดที่พิมพ์ในแง่นี้

นอกจากนี้รูปแบบของลูกแกะก็ไม่สามารถสะกดได้เช่นกันดังนั้นauto f = []...สไตล์ที่ดี ทางเลือกคือการหล่อstd::functionแต่ที่มาพร้อมกับค่าใช้จ่าย

ฉันไม่สามารถจริงๆตั้งครรภ์ของ "ละเมิด" autoของ สิ่งที่ใกล้เคียงที่สุดที่ฉันสามารถจินตนาการได้คือการกีดกันการแปลงที่ชัดเจนเป็นประเภทที่มีความสำคัญ - แต่คุณจะไม่ใช้autoสิ่งนั้นคุณจะสร้างวัตถุประเภทที่ต้องการ

หากคุณสามารถลบความซ้ำซ้อนบางอย่างในรหัสของคุณโดยไม่ต้องใช้ผลข้างเคียงจากนั้นจะต้องเป็นการดีที่จะทำเช่นนั้น

ตัวอย่าง (ยืมมาจากคำตอบของคนอื่น):

auto i = SomeClass();
for (auto x = make_unsigned (y); ...)

ที่นี่เราสนใจสิ่งที่เป็นประเภทดังนั้นเราควรเขียนSomeclass i;และfor(unsigned x = y;...

ไปเลย ใช้autoทุกที่ที่ทำให้การเขียนโค้ดง่ายขึ้น

คุณลักษณะใหม่ทุกภาษาไม่ว่าจะเป็นโปรแกรมเมอร์อย่างน้อยบางประเภท มันเป็นเพียงผ่านมากเกินไปในระดับปานกลางโดยโปรแกรมเมอร์ที่มีประสบการณ์บางคน (ไม่ใช่ noobs) ที่เหลือของโปรแกรมเมอร์ที่มีประสบการณ์เรียนรู้ขอบเขตของการใช้งานที่เหมาะสม การใช้งานมากเกินไปมากมักจะไม่ดี แต่อาจดีเพราะการใช้งานมากเกินไปอาจนำไปสู่การปรับปรุงคุณสมบัติหรือคุณสมบัติที่ดีกว่าเพื่อแทนที่

แต่ถ้าฉันทำงานกับโค้ดที่มีมากกว่าสองสามบรรทัดเช่น

auto foo = bla();

เมื่อชนิดถูกระบุศูนย์ครั้งฉันอาจต้องการเปลี่ยนบรรทัดเหล่านั้นเพื่อรวมประเภท ตัวอย่างแรกนั้นยอดเยี่ยมเนื่องจากมีการระบุชนิดหนึ่งครั้งและautoช่วยให้เราไม่ต้องเขียนประเภทเทมเพลตยุ่ง ๆ สองครั้ง ไชโยสำหรับ C ++++ แต่การแสดงประเภทศูนย์ครั้งชัดเจนถ้ามันไม่สามารถมองเห็นได้ง่ายในแถวใกล้เคียงทำให้ฉันกังวลอย่างน้อยใน C ++ และผู้สืบทอดทันที สำหรับภาษาอื่น ๆ ที่ออกแบบมาเพื่อทำงานในระดับที่สูงขึ้นด้วยความเป็นนามธรรม, ความหลากหลายและความเป็นสากลก็ดี

ในC ++ และหลังปี 2012ในถามอะไรเราแผงมีการแลกเปลี่ยนที่ยอดเยี่ยมระหว่างอังเดร Alexandrescu สกอตต์เมเยอร์สและสมุนไพร Sutter autoพูดถึงเมื่อจะใช้งานและไม่ได้ใช้งาน ข้ามไปยังนาที 25:03 สำหรับการสนทนา 4 นาที ทั้งสามลำโพงให้จุดที่ดีที่ควรจะเก็บไว้ในใจเมื่อจะไม่ได้autoใช้

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

1. มันเจ็บการอ่าน
2. มีความกังวลเกี่ยวกับการแปลงชนิดอัตโนมัติ (เช่นจากตัวสร้างการกำหนดประเภทกลางของแม่แบบการแปลงโดยนัยระหว่างความกว้างของจำนวนเต็ม)

การใช้เสรีexplicitช่วยลดความกังวลสำหรับหลังซึ่งช่วยลดระยะเวลาที่อดีตเป็นปัญหา

กล่าวซ้ำในสิ่งที่ Herb พูดว่า "ถ้าคุณไม่ได้ทำ X, Y และ Z ให้ใช้autoเรียนรู้ว่า X, Y และ Z คืออะไรและออกไปข้างนอกแล้วใช้autoที่ไหนก็ได้"

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

   for(auto i = container.begin(); i != container.end(); ++i);

auto ที่นี่ไม่เจ็บการอ่าน

อีกตัวอย่างคือประเภทกฎตัวแยกวิเคราะห์ซึ่งสามารถยาวและซับซ้อน เปรียบเทียบ:

   auto spaces = space & space & space;

กับ

r_and_t<r_and_t<r_char_t<char>&, r_char_t<char>&>, r_char_t<char>&> spaces = 
   space & space & space;

ในทางกลับกันเมื่อเป็นที่รู้จักและเรียบง่ายมันจะดีกว่าถ้ามันระบุไว้อย่างชัดเจน:

int i = foo();

ค่อนข้างมากกว่า

auto i = foo();

auto อาจเป็นอันตรายอย่างยิ่งเมื่อใช้ร่วมกับเทมเพลตการแสดงออกที่ใช้บ่อยโดยห้องสมุดพีชคณิตเชิงเส้นเช่น Eigen หรือ OpenCV

auto A = Matrix(...);
auto B = Matrix(...);
auto C = A * B; // C is not a matrix. It is a matrix EXPRESSION.
cout << C; // The expression is evaluated and gives the expected result.
... // <code modifying A or B>
cout << C; // The expression is evaluated AGAIN and gives a DIFFERENT result.

ข้อบกพร่องที่เกิดจากข้อผิดพลาดประเภทนี้เป็นความเจ็บปวดที่สำคัญในการแก้ปัญหา วิธีแก้ไขที่เป็นไปได้วิธีหนึ่งคือการส่งผลลัพธ์ไปยังประเภทที่คาดหวังไว้อย่างชัดเจนหากคุณใช้งานอัตโนมัติสำหรับรูปแบบการประกาศจากซ้ายไปขวา

auto C = Matrix(A * B); // The expression is now evaluated immediately.

ฉันใช้การautoจำกัด โดยไม่มีข้อ จำกัด และไม่ประสบปัญหาใด ๆ intฉันแม้บางครั้งจะสิ้นสุดการใช้มันสำหรับประเภทง่ายๆเช่น นี่ทำให้ c ++ เป็นภาษาระดับที่สูงขึ้นสำหรับฉันและอนุญาตให้ประกาศตัวแปรใน c ++ เหมือนใน python หลังจากเขียนรหัสไพ ธ อนบางครั้งฉันก็เขียนเช่น

auto i = MyClass();

แทน

MyClass i;

นี่เป็นกรณีหนึ่งที่ฉันจะบอกว่ามันเป็นการละเมิดautoคำหลัก

บ่อยครั้งที่ฉันไม่คิดว่าสิ่งที่เป็นชนิดที่แน่นอนของวัตถุที่ผมสนใจมากขึ้นใน fonctionality ของตนและเป็นชื่อที่ฟังก์ชั่นโดยทั่วไปพูดอะไรบางอย่างเกี่ยวกับวัตถุที่พวกเขากลับautoไม่เจ็บ: ในเช่นauto s = mycollection.size()ผมสามารถเดาว่าsจะเป็น ชนิดของจำนวนเต็มและในกรณีที่หายากที่ฉันสนใจเกี่ยวกับประเภทที่แน่นอนให้ตรวจสอบต้นแบบฟังก์ชั่นแล้ว (ฉันหมายความว่าฉันต้องการที่จะตรวจสอบเมื่อฉันต้องการข้อมูลแทนที่จะเป็นนิรนัยเมื่อรหัสถูกเขียนเพียง ในกรณีที่มันจะเป็นประโยชน์ทั้งวันเช่นเดียวกับในint_type s = mycollection.size())

เกี่ยวกับตัวอย่างนี้จากคำตอบที่ยอมรับ:

for ( auto x = max_size; x > 0; --x )

ในรหัสของฉันฉันยังคงใช้autoในกรณีนี้และถ้าฉันต้องการxที่จะไม่ได้ลงนามแล้วฉันจะใช้ฟังก์ชั่นยูทิลิตี้ชื่อพูดmake_unsignedซึ่งแสดงความกังวลของฉันอย่างชัดเจน:

for ( auto x = make_unsigned(max_size); x > 0; --x )

ข้อจำกัดความรับผิดชอบ: ฉันแค่อธิบายการใช้งานของฉันฉันไม่สามารถให้คำแนะนำ!

ปัญหาหลักอย่างหนึ่งของโปรแกรม C ++ คือช่วยให้คุณใช้ตัวแปรที่ไม่ได้กำหนดค่าเริ่มต้น สิ่งนี้ทำให้เรามีพฤติกรรมโปรแกรมที่ไม่น่ารังเกียจ ควรสังเกตว่าคอมไพเลอร์สมัยใหม่โยนข้อความเตือน / ข้อความที่เหมาะสมหากโปรแกรมยางใช้งาน

เพียงเพื่อแสดงให้เห็นถึงการพิจารณาด้านล่างโปรแกรม c ++:

int main() {
    int x;
    int y = 0;
    y += x;
}

ถ้าฉันคอมไพล์โปรแกรมนี้โดยใช้คอมไพเลอร์สมัยใหม่ (GCC) มันจะให้คำเตือน คำเตือนดังกล่าวอาจไม่ชัดเจนหากเรากำลังทำงานกับรหัสการผลิตที่ซับซ้อนจริง

main.cpp: ในฟังก์ชัน 'int main ()':

main.cpp: 4: 8: คำเตือน : 'x' ถูกใช้โดยไม่กำหนดค่าเริ่มต้นในฟังก์ชั่นนี้ [-Wuninitialized]

y + = x;

    ^

================================================== =============================== ทีนี้ถ้าเราเปลี่ยนโปรแกรมของเราซึ่งใช้ autoแล้วคอมไพล์เราจะได้ข้อมูลดังนี้:

int main() {
    auto x;
    auto y = 0;
    y += x;
}

main.cpp: ในฟังก์ชัน 'int main ()':

main.cpp: 2: 10: ข้อผิดพลาด : การประกาศ 'auto x' ไม่มี initializer

 auto x;

      ^

ด้วย auto มันเป็นไปไม่ได้ที่จะใช้ตัวแปร uninitialized นี่คือประโยชน์ที่สำคัญซึ่งเราอาจได้รับ (ฟรี) ถ้าเราเริ่มต้นการใช้รถยนต์

แนวคิดนี้และแนวคิด C ++ ที่ยอดเยี่ยมทันสมัยอื่น ๆ อธิบายโดยผู้เชี่ยวชาญ C ++ Herb ShutterในการพูดคุยCppCon14ของเขา:

กลับไปสู่พื้นฐาน! Essentials of Modern C ++ Style

อันตรายอย่างหนึ่งที่ฉันสังเกตเห็นคือการอ้างอิง เช่น

MyBigObject& ref_to_big_object= big_object;
auto another_ref = ref_to_big_object; // ?

ปัญหาคือ another_ref ไม่ใช่การอ้างอิงจริงในกรณีนี้คือ MyBigObject แทน MyBigObject & คุณจะต้องคัดลอกวัตถุขนาดใหญ่โดยที่ไม่รู้ตัว

หากคุณได้รับการอ้างอิงโดยตรงจากวิธีการที่คุณอาจไม่คิดว่ามันคืออะไร

auto another_ref = function_returning_ref_to_big_object();

คุณจะต้องมี "auto &" หรือ "const auto &"

MyBigObject& ref_to_big_object= big_object;
auto& another_ref = ref_to_big_object;
const auto& yet_another_ref = function_returning_ref_to_big_object();

ใช้autoตำแหน่งที่เหมาะสมสำหรับประเภทที่จะอนุมาน หากคุณมีสิ่งที่คุณรู้ว่าเป็นจำนวนเต็มหรือคุณรู้ว่ามันเป็นสตริงเพียงแค่ใช้ int / std :: string ฯลฯ ฉันจะไม่กังวลเกี่ยวกับ "มากเกินไป" คุณสมบัติภาษาเว้นแต่ว่ามันจะถึงจุดที่ไร้สาระ หรือรหัสทำให้งงงวย

นั่นคือความคิดเห็นของฉัน

autoคีย์เวิร์ดสามารถใช้ได้เฉพาะกับตัวแปรโลคัลเท่านั้นไม่สามารถใช้กับอาร์กิวเมนต์หรือสมาชิกคลาส / โครงสร้าง ดังนั้นจึงปลอดภัยและใช้งานได้ทุกที่ที่คุณต้องการ ฉันจะใช้พวกเขามาก ชนิดถูกอนุมาน ณ เวลาที่รวบรวมดีบักเกอร์แสดงชนิดขณะทำการดีบักsizeofรายงานอย่างถูกต้องรายงานdecltypeจะให้ประเภทที่ถูกต้อง - ไม่มีอันตรายใด ๆ ฉันไม่นับautoว่าใช้มากเกินไป!

TL; DR: ดูกฎของหัวแม่มือที่ด้านล่าง

คำตอบที่ได้รับการยอมรับให้เห็นกฎต่อไปนี้ของหัวแม่มือ:

ใช้autoเมื่อใดก็ตามที่ยากที่จะบอกวิธีเขียนประเภทตั้งแต่แรกเห็น แต่ประเภทของด้านขวามือของนิพจน์นั้นชัดเจน

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

auto x = f();

สิ่งที่ทำให้นี้เป็นตัวอย่างของการใช้ผิดวัตถุประสงค์ของauto? มันเป็นความเขลาของf()ประเภทการคืนสินค้าหรือไม่? มันอาจช่วยได้ถ้าฉันรู้ แต่นั่นไม่ใช่ความกังวลหลักของฉัน อะไรคือสิ่งที่มากขึ้นของปัญหาคือการที่xและf()มีความหมายสวย ถ้าเรามี:

auto nugget = mine_gold();

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

ดังนั้นคำตอบของฉันคือ: ใช้autoเมื่อใดก็ตามที่คอมไพเลอร์อนุญาตเว้นแต่:

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

และนอกจากนี้ยังมี:

• ต้องการให้ชื่อที่มีความหมาย (ซึ่งไม่มีชื่อประเภทของหลักสูตร) ​​ก่อนที่จะแทนที่autoด้วยประเภทที่เป็นรูปธรรม

หนึ่งในประสบการณ์ที่ขมขื่นของฉันautoคือการใช้มันด้วยการแสดงออกแลมบ์ดา :

auto i = []() { return 0; };
cout<<"i = "<<i<<endl; // output: 1 !!!

ที่จริงที่นี่ได้รับการแก้ไขเพื่อตัวชี้การทำงานของi int(*)()นี่เป็นเพียงเรียบง่ายcoutแต่เพียงจินตนาการสิ่งที่ชนิดของข้อผิดพลาดการรวบรวม / templateรันไทม์ที่ไม่ดีก็สามารถทำให้เกิดเมื่อใช้กับ

คุณควรหลีกเลี่ยง autoด้วยนิพจน์ดังกล่าวและใส่returnประเภทที่เหมาะสม(หรือควบคุมdecltype())

การใช้งานที่ถูกต้องสำหรับตัวอย่างด้านบนจะเป็น

auto i = []() { return 0; }(); // and now i contains the result of calling the lambda