Neden iostream :: eof bir döngü koşulu içinde (yani `` while (! Stream.eof ()) `) yanlış kabul ediliyor?

Bu cevapta iostream::eofbir döngü koşulunda kullanmanın "neredeyse kesinlikle yanlış" olduğunu söyleyen bir yorum buldum . Genellikle while(cin>>n)örtük olarak EOF kontrol eder gibi bir şey kullanıyorum .

Neden açıkça kullanıldığını kontrol etmek while (!cin.eof())yanlış?

scanf("...",...)!=EOFC (çoğunlukla problemsiz kullandığım) ile kullanmak arasındaki fark nedir?

Çünkü iostream::eofsadece akışın sonunu okuduktan true sonra geri dönecektir . O mu değil sonraki okuma akışının sonu olacağını belirtmek.

Bunu düşünün (ve bir sonraki okumanın akışın sonunda olacağını varsayalım):

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
}

Buna karşı:

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)
}

İkinci sorunuzda: Çünkü

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

aynıdır

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

ve aynı değil

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

Alt satır üstü: Beyaz boşluğun doğru kullanımı ile aşağıdakiler nasıl eofkullanılabilir (ve hatta fail()hata kontrolünden daha güvenilir olabilir ):

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

( Cevabı vurgulama önerisi için Tony D'ye teşekkürler. Bunun neden daha sağlam olduğuna dair bir örnek için aşağıdaki yorumuna bakın. )

Kullanmaya karşı ana argümanın eof(), beyaz alanın rolü hakkında önemli bir incelik eksik olduğu görülmektedir. Benim önerim, eof()açıkça kontrol etmek sadece " her zaman yanlış " değil - bu ve benzer SO iş parçacıkları üzerinde baskın bir fikir gibi görünüyor - ama beyaz boşluğun düzgün bir şekilde işlenmesi ile daha temiz ve daha güvenilir bir yöntem sağlıyor. hata işleme ve her zaman doğru çözümdür (her ne kadar tersi olmasa da).

"Uygun" sonlandırma ve okuma sırası olarak önerilenleri özetlemek gerekirse:

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

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

Bunun ötesinde okuma girişiminden kaynaklanan başarısızlık, fesih koşulu olarak kabul edilir. Bunun anlamı, başarılı bir akış ile gerçekten başka nedenlerden dolayı başarısız olan bir akışı ayırt etmenin kolay bir yolu olmadığıdır. Aşağıdaki akışları alın:

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

while(in>>data)her üç giriş failbitiçin de bir set ile sonlanır . Birinci ve üçüncü olarak da ayarlanır. Bu yüzden döngüden sonra, uygun bir girişi (1.) uygunsuz olanlardan (2. ve 3.) ayırmak için çok çirkin ekstra mantığa ihtiyaç vardır.eofbit

Halbuki aşağıdakileri yapın:

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

Burada, in.fail()okunacak bir şey olduğu sürece, doğru olduğunu doğrular. Amacı sadece bir while döngüsü sonlandırıcı değildir.

Şimdiye kadar çok iyi, ama akışta izleyen alan varsa ne olur - eof()terminatör olarak büyük endişe gibi ne olur ?

Hata işlememizi teslim etmemize gerek yok; sadece beyaz alanı yiyin:

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::wsayarlanırken akışında yer arka herhangi bir potansiyel (sıfır ya da daha fazla) atlar eofbitve değildirfailbit . Bu nedenle, in.fail()okunacak en az bir veri olduğu sürece beklendiği gibi çalışır. Tamamen boş akışlar da kabul edilebilirse, doğru form:

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
}

Özet: Düzgün bir şekilde yapılanma while(!eof)sadece mümkün değildir ve yanlış değildir, aynı zamanda verilerin kapsam içinde yerelleştirilmesine izin verir ve hata kontrolünün her zamanki gibi işten daha net bir şekilde ayrılmasını sağlar. Bununla birlikte while(!fail), tartışmasız daha yaygın ve kısa bir deyimdir ve basit (okuma türü başına tek veri) senaryolarda tercih edilebilir.

Çünkü programcılar yazmazsa while(stream >> n), muhtemelen bunu yazarlar:

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

Sorun şu ki, some work on nönce akışın başarılı olup olmadığını kontrol etmeden yapamazsınız , çünkü başarısız olursa, some work on nistenmeyen sonuç üretersiniz.

Bütün noktası, yani eofbit, badbitya da failbitayarlanır girişimi akışından okumak amacıyla yapıldıktan sonra. Eğer stream >> nbaşarısız olursa, o zaman eofbit, badbitya failbitda hemen ayarlanırsa, yazdığınızda daha deyimsel olur while (stream >> n), çünkü döndürülen nesne akıştan okumada bir hata varsa streamdönüşür falseve sonuç olarak döngü durur. Ve trueokumanın başarılı olup olmadığına ve döngü devam edip etmediğine dönüşür .

Diğer cevaplar mantığın neden yanlış olduğunu while (!stream.eof())ve nasıl düzeltileceğini açıkladı. Farklı bir şeye odaklanmak istiyorum:

eof neden açıkça iostream::eofyanlış kullanarak denetleniyor ?

Genel olarak, akış ayıklama ( ) dosyası sonuna gelmeden başarısız olabileceğinden eof yalnızca denetleme yanlıştır >>. Örneğiniz varsa int n; cin >> n;ve akış içeriyorsa hello, hgeçerli bir basamak değildir, bu nedenle girişin sonuna ulaşılmadan çıkarma işlemi başarısız olur.

Bu sorun, ondan okumaya başlamadan önce akış durumunu kontrol etme genel mantık hatası ile birleştiğinde, N giriş öğeleri için döngü N + 1 kez çalışacağı anlamına gelir:

• Akış boşsa, döngü bir kez çalışır. >>başarısız olur (okunacak girdi yoktur) ve (tarafından stream >> x) ayarlanması gereken tüm değişkenler aslında başlatılmaz. Bu, saçma sonuçların (genellikle çok sayıda) ortaya çıkabilen çöp verilerinin işlenmesine yol açar.

  (Standart kitaplığınız C ++ 11 ile uyumluysa, işler şimdi biraz farklıdır: Başarısız, >>artık sayısal değişkenleri 0başlatılmamış bırakmak yerine ( chars hariç ) ayarlar .)

• Akış boş değilse, döngü son geçerli girişten sonra tekrar çalışır. Son yinelemede tüm >>işlemler başarısız olduğundan, değişkenler değerlerini önceki yinelemeden koruyabilir. Bu "son satır iki kez yazdırılır" veya "son giriş kaydı iki kez işlenir" şeklinde gösterilebilir.

  (Bu, C ++ 11'den beri biraz farklı görünmelidir (yukarıya bakın): Şimdi tekrarlanan son satır yerine sıfırların "hayali bir kaydını" alıyorsunuz.)

• Akış hatalı biçimlendirilmiş veriler içeriyorsa, ancak yalnızca kontrol .eofediyorsanız, sonsuz bir döngü elde edersiniz. >>akıştan herhangi bir veri çıkartamaz, böylece döngü sonuna kadar ulaşmadan yerinde döner.

Özetle: çözüm başarısını test etmektir >>operasyon kendisi ayrı kullanmamaya .eof()yöntemi: while (stream >> n >> m) { ... }, sen başarısını test sadece C olarak scanfçağrı kendisi: while (scanf("%d%d", &n, &m) == 2) { ... }.