ฉันควรใช้คุณสมบัติ 'อัตโนมัติ' C ++ 11 ใหม่โดยเฉพาะในลูปหรือไม่

ข้อดี / ข้อเสียของการใช้autoคำหลักโดยเฉพาะในลูปคืออะไร

for(std::vector<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->something();
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->second->something();
}

for(auto it = x.begin(); it != x.end(); it++ )
{
   it->??
}

ดูเหมือนว่าถ้าคุณไม่รู้ว่าคุณมีตัววนซ้ำสำหรับแผนที่หรือเวกเตอร์คุณจะไม่รู้ว่าจะใช้หรือไม่ firstหรือsecondเข้าถึงคุณสมบัติของวัตถุโดยตรงหรือไม่?

สิ่งนี้ทำให้ฉันนึกถึงการโต้วาที C # ว่าจะใช้คำหลักvarหรือไม่ ความประทับใจที่ฉันได้รับจนถึงขณะนี้คือในโลกคน C ++ พร้อมที่จะใช้autoคำหลักที่มีการต่อสู้น้อยกว่าvarในโลก C # สำหรับฉันสัญชาตญาณแรกของฉันคือฉันชอบที่จะรู้ชนิดของตัวแปรเพื่อที่ฉันจะได้รู้ว่าการดำเนินการใดที่ฉันคาดหวังว่าจะสามารถทำได้

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

boost::multi_map<NodeType, indexed_by<ordered_unique<identity<NodeType>>, hashed_non_unique<identity<NodeType>, custom_hasher>>::iterator_type<0> it

นั่นไม่ใช่แม้แต่แบบเต็มรูปแบบ ฉันพลาดข้อโต้แย้งของแม่แบบคู่

ในตัวอย่างของคุณ:

for(auto it = x.begin(); it != x.end(); i++)
{
  it->??
}

จะต้องมีการประกาศให้xมองเห็นได้ ดังนั้นประเภทของitควรชัดเจน หากประเภทของxไม่ชัดเจนแสดงว่าวิธีนั้นยาวเกินไปหรือคลาสมีขนาดใหญ่เกินไป

คัดค้าน ! คำถามที่โหลด

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

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->???
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->second->???
}

ที่นั่น ปัญหาเดียวกันแม้ว่าคุณจะไม่ได้ใช้autoปัญหาเดียวกันแม้ว่าคุณไม่ได้ใช้

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

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

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

มือโปร

รหัสของคุณ:

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

จะไม่คอมไพล์เนื่องจากชื่อที่ขึ้นกับเทมเพลต

นี่คือไวยากรณ์ที่ถูกต้อง:

for( typename std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

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

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

กระชับยิ่งขึ้น ดังนั้นนี่คือมืออาชีพ

CON

คุณต้องระวังหน่อย ด้วยคำหลักautoคุณจะได้รับประเภทที่คุณประกาศ

ตัวอย่างเช่น :

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto it : v )
{
  ++ it;   // ops modifying copies of vector's elements
}

VS

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto & it : v )   // mind the reference
{
  ++ it;   // ok, vector's elements modified
}

เพื่อสรุป: ใช่คุณควร แต่ไม่ควรใช้มากเกินไป บางคนมักจะใช้มันมากเกินไปและวางอัตโนมัติทุกที่อย่างเช่นในตัวอย่างถัดไป:

auto i = 0;

VS

int i = 0;

ใช่คุณควรจะ! autoไม่ลบประเภท; แม้ว่าคุณ "ไม่รู้" x.begin()คืออะไรคอมไพเลอร์รู้และจะรายงานข้อผิดพลาดหากคุณพยายามใช้ประเภทผิด นอกจากนี้ยังไม่ผิดปกติที่จะเลียนแบบmapด้วยvector<pair<Key,Value>>ดังนั้นรหัสที่ใช้autoจะทำงานได้ดีกับทั้งพจนานุกรม

ใช่คุณควรใช้autoเป็นกฎเริ่มต้น มันมีข้อได้เปรียบแบบดิบเหนือการระบุประเภทอย่างชัดเจน:

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

ที่นี่คุณมีทางเลือก นอกจากนี้ยังมีกรณีที่คุณไม่มีทางเลือก:

• อนุญาตให้มีการประกาศตัวแปรชนิดที่ไม่สามารถตัดทอนได้เช่นเดียวกับแลมบ์ดา

หากว่าคุณรู้แน่ชัดว่าautoมันทำอะไรก็ไม่มีข้อเสีย