ทำไม iostream :: eof ภายในสภาพลูป (เช่น `while (! stream.eof ())`) ถือว่าผิด

ฉันเพิ่งพบความคิดเห็นในคำตอบนี้บอกว่าการใช้iostream::eofในสภาพลูปคือ "เกือบผิดแน่นอน" ฉันมักจะใช้สิ่งที่ชอบwhile(cin>>n)- ซึ่งฉันเดาว่าจะตรวจสอบ EOF โดยปริยาย

เหตุใดการตรวจสอบว่ามีการใช้while (!cin.eof())ผิดอย่างชัดเจนหรือไม่

มันแตกต่างจากการใช้scanf("...",...)!=EOFใน C (ซึ่งฉันมักจะใช้ไม่มีปัญหา)?

เพราะiostream::eofจะกลับมาtrue หลังจากอ่านจุดสิ้นสุดของกระแส ไม่ได้ระบุว่าการอ่านครั้งต่อไปจะเป็นจุดสิ้นสุดของสตรีม

พิจารณาสิ่งนี้ (และสมมติว่าการอ่านครั้งถัดไปจะเป็นตอนท้ายสตรีม):

while(!inStream.eof()){
  int data;
  // yay, not end of stream yet, now read ...
  inStream >> data;
  // oh crap, now we read the end and *only* now the eof bit will be set (as well as the fail bit)
  // do stuff with (now uninitialized) data
}

กับสิ่งนี้:

int data;
while(inStream >> data){
  // when we land here, we can be sure that the read was successful.
  // if it wasn't, the returned stream from operator>> would be converted to false
  // and the loop wouldn't even be entered
  // do stuff with correctly initialized data (hopefully)
}

และในคำถามที่สองของคุณ: เพราะ

if(scanf("...",...)!=EOF)

เป็นเช่นเดียวกับ

if(!(inStream >> data).eof())

และไม่เหมือนกัน

if(!inStream.eof())
    inFile >> data

ด้านล่างบรรทัด: ด้วยการจัดการพื้นที่สีขาวที่เหมาะสมต่อไปนี้เป็นวิธีการeofใช้ (และแม้กระทั่งเชื่อถือได้มากกว่าfail()สำหรับการตรวจสอบข้อผิดพลาด):

while( !(in>>std::ws).eof() ) {  
   int data;
   in >> data;
   if ( in.fail() ) /* handle with break or throw */; 
   // now use data
}    

( ขอบคุณ Tony D สำหรับคำแนะนำเพื่อเน้นคำตอบดูความคิดเห็นของเขาด้านล่างเพื่อดูว่าทำไมสิ่งนี้ถึงมีประสิทธิภาพมากกว่านี้ )

ข้อโต้แย้งหลักต่อการใช้eof()ดูเหมือนจะไม่มีความละเอียดอ่อนที่สำคัญเกี่ยวกับบทบาทของพื้นที่สีขาว ข้อเสนอของฉันคือการตรวจสอบeof()อย่างชัดเจนไม่เพียง แต่ไม่ " ผิดเสมอไป " - ซึ่งดูเหมือนว่าจะเป็นความคิดเห็นที่สำคัญในหัวข้อนี้และหัวข้อ SO ที่คล้ายกัน - แต่ด้วยการจัดการพื้นที่สีขาวที่เหมาะสม การจัดการข้อผิดพลาดและเป็นวิธีการแก้ไขที่ถูกต้องเสมอ (แม้ว่าไม่จำเป็นต้องเข้มงวดที่สุด)

เพื่อสรุปสิ่งที่ถูกแนะนำว่าเป็นการสิ้นสุด "เหมาะสม" และลำดับการอ่านมีดังต่อไปนี้:

int data;
while(in >> data) {  /* ... */ }

// which is equivalent to 
while( !(in >> data).fail() )  {  /* ... */ }

ความล้มเหลวเนื่องจากความพยายามในการอ่านเกินกว่า eof ถือเป็นเงื่อนไขการเลิกจ้าง นี่หมายความว่าไม่มีวิธีง่ายๆในการแยกแยะระหว่างสตรีมที่ประสบความสำเร็จและสตรีมที่ประสบความสำเร็จด้วยเหตุผลอื่นนอกเหนือจาก eof ใช้สตรีมต่อไปนี้:

• 1 2 3 4 5<eof>
• 1 2 a 3 4 5<eof>
• a<eof>

while(in>>data)ยุติกับชุดfailbitสำหรับทุกสามการป้อนข้อมูล ในครั้งแรกและครั้งที่สามeofbitก็มีการตั้งค่า ดังนั้นในอดีตลูปจึงต้องการตรรกะพิเศษที่น่าเกลียดมาก ๆ เพื่อแยกอินพุตที่เหมาะสม (ที่ 1) จากอันที่ไม่เหมาะสม (ที่ 2 และที่ 3)

ในขณะที่ทำสิ่งต่อไปนี้:

while( !in.eof() ) 
{  
   int data;
   in >> data;
   if ( in.fail() ) /* handle with break or throw */; 
   // now use data
}    

ที่นี่in.fail()ตรวจสอบว่าตราบใดที่มีบางสิ่งที่จะอ่านมันเป็นสิ่งที่ถูกต้อง มันมีจุดประสงค์ไม่ได้เป็นเพียง terminator ในขณะที่วง

จนถึงตอนนี้ดีมาก แต่เกิดอะไรขึ้นถ้ามีช่องว่างต่อท้ายในสตรีม - สิ่งที่ฟังดูเป็นข้อกังวลที่สำคัญeof()ในฐานะเทอร์มิเนเตอร์

เราไม่จำเป็นต้องยอมจำนนการจัดการข้อผิดพลาดของเรา; แค่กินพื้นที่สีขาว:

while( !in.eof() ) 
{  
   int data;
   in >> data >> ws; // eat whitespace with std::ws
   if ( in.fail() ) /* handle with break or throw */; 
   // now use data
}

std::wsข้ามที่อาจเกิดขึ้น (ศูนย์หรือมากกว่า) พื้นที่ต่อท้ายในกระแสในขณะที่การตั้งค่าeofbitและไม่ได้เป็น failbitดังนั้นin.fail()ทำงานได้ตามที่คาดหวังตราบใดที่มีข้อมูลอย่างน้อยหนึ่งที่จะอ่าน หากกระแสทั้งหมดที่ว่างเปล่ายังเป็นที่ยอมรับรูปแบบที่ถูกต้องคือ:

while( !(in>>ws).eof() ) 
{  
   int data;
   in >> data; 
   if ( in.fail() ) /* handle with break or throw */; 
   /* this will never fire if the eof is reached cleanly */
   // now use data
}

สรุป:การสร้างอย่างถูกต้องwhile(!eof)ไม่เพียง แต่เป็นไปได้และไม่ผิดเท่านั้น แต่ยังช่วยให้ข้อมูลสามารถแปลได้ภายในขอบเขตและให้การแยกการตรวจสอบข้อผิดพลาดที่ชัดเจนจากธุรกิจตามปกติ ที่ถูกกล่าวว่าwhile(!fail)อาจเป็นสำนวนที่พบบ่อยและสั้นและอาจเป็นที่ต้องการในสถานการณ์ (ข้อมูลเดียวต่อประเภทการอ่าน) ที่เรียบง่าย

เพราะถ้าโปรแกรมเมอร์ไม่เขียนwhile(stream >> n)พวกเขาอาจจะเขียนสิ่งนี้:

while(!stream.eof())
{
    stream >> n;
    //some work on n;
}

ที่นี่ปัญหาคือคุณไม่สามารถทำได้some work on nโดยไม่ตรวจสอบก่อนว่าการอ่านสตรีมสำเร็จหรือไม่เพราะถ้าไม่สำเร็จคุณsome work on nจะได้ผลลัพธ์ที่ไม่พึงประสงค์

จุดรวมคือว่าeofbit, badbitหรือfailbitมีการตั้งค่าหลังจากที่พยายามที่จะอ่านจากกระแส ดังนั้นถ้าstream >> nล้มเหลวแล้วeofbit, badbitหรือfailbitการตั้งค่าทันทีดังนั้นสำนวนมากขึ้นถ้าคุณเขียนwhile (stream >> n)เพราะวัตถุกลับมาstreamแปรรูปfalseถ้ามีความล้มเหลวในการอ่านบางส่วนจากกระแสและจึงหยุดห่วง และมันจะแปลงtrueหากการอ่านประสบความสำเร็จและการวนซ้ำจะดำเนินต่อไป

คำตอบอื่น ๆ ได้อธิบายว่าทำไมตรรกะไม่ถูกต้องwhile (!stream.eof())และวิธีการแก้ไข ฉันต้องการเน้นสิ่งที่แตกต่าง:

เหตุใดจึงตรวจสอบว่ามีการใช้iostream::eofผิดอย่างชัดเจนหรือไม่

โดยทั่วไปการตรวจสอบeof เพียงอย่างเดียวนั้นผิดเนื่องจากการดึงข้อมูลกระแสข้อมูล ( >>) อาจล้มเหลวโดยไม่ต้องกดจุดสิ้นสุดไฟล์ หากคุณมีเช่นint n; cin >> n;และสตรีมที่มีอยู่helloแล้วhอยู่ไม่ใช่ตัวเลขที่ถูกต้องดังนั้นการดึงข้อมูลจะล้มเหลวโดยไม่ถึงจุดสิ้นสุดของอินพุต

ปัญหานี้รวมกับข้อผิดพลาดทางตรรกะทั่วไปของการตรวจสอบสถานะกระแสก่อนที่จะพยายามอ่านจากมันซึ่งหมายความว่าสำหรับรายการอินพุต N การวนซ้ำจะเรียกใช้ N + 1 ครั้งทำให้เกิดอาการต่อไปนี้:

• หากสตรีมว่างเปล่าลูปจะทำงานหนึ่งครั้ง >>จะล้มเหลว (ไม่มีอินพุตที่จะอ่าน) และตัวแปรทั้งหมดที่ควรจะถูกตั้งค่า (โดยstream >> x) จะถูกกำหนดค่าเริ่มต้นจริง ๆ สิ่งนี้นำไปสู่การประมวลผลข้อมูลขยะซึ่งอาจแสดงให้เห็นว่าเป็นผลลัพธ์ที่ไร้สาระ (มักเป็นจำนวนมาก)

  (หากไลบรารี่มาตรฐานของคุณสอดคล้องกับ C ++ 11 ตอนนี้สิ่งต่าง ๆ จะแตกต่างกันเล็กน้อยตอนนี้ความล้มเหลวใน>>ขณะนี้จะตั้งค่าตัวแปรตัวเลขให้0แทนที่จะปล่อยให้ไม่มีการกำหนดค่าเริ่มต้น (ยกเว้นสำหรับchar)

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

  (สิ่งนี้ควรแสดงให้เห็นแตกต่างไปเล็กน้อยตั้งแต่ C ++ 11 (ดูด้านบน): ตอนนี้คุณจะได้รับ "บันทึกภาพหลอน" เป็นศูนย์แทนที่จะเป็นบรรทัดสุดท้ายซ้ำ)

• หากสตรีมมีข้อมูลที่มีรูปแบบไม่ถูกต้อง แต่คุณตรวจสอบเท่านั้น.eofคุณจะพบกับการวนซ้ำไม่สิ้นสุด >>จะไม่สามารถดึงข้อมูลใด ๆ จากสตรีมได้ดังนั้นลูปจะเข้าที่โดยไม่สิ้นสุด

สรุป: การแก้ปัญหาคือการทดสอบความสำเร็จของ>>การดำเนินงานของตัวเองที่จะไม่ใช้แยก.eof()วิธีการ: while (stream >> n >> m) { ... }เช่นเดียวกับใน C คุณทดสอบความสำเร็จของการที่เรียกตัวเอง:scanfwhile (scanf("%d%d", &n, &m) == 2) { ... }