Newsgroup: it.comp.lang.c++
Titolo: leggere tutto un file senza uso di feof....

Il problema è che utilizzando il controllo feof mi interrompe la lettura del
file prima che raggiunga la vera fine del file..
Come posso leggere un file senza utilizzare questo controllo....
grazie..


Ad esempio puoi leggere una riga alla volta con
string line;
while ( getline( filein, s ) )
    Elabora_la_riga();
EMG

 Come posso leggere un file senza utilizzare questo controllo....
Per leggere un intero file in memoria in un solo colpo,
in C++, il modo piu` semplice e` probabilmente:
void leggitutto(std::istream& ist, std::string& result)
{
    std::stringbuf ost(std::ios_base::out);
    ist >> &ost;
    result.swap(ost.str());
}
Alex

 }
A parte il fatto del "semplice" che č molto relativo, volevo chiederti
se in C++ standard si deve utilizzare quindi std::ios_base e non piů ios
come si faceva una volta?
EMG

 come si faceva una volta?
std::ios_base descrive tutto cio` che non dipende da parametri
di template, tipo i flag come out.  Puoi sicuramente
usare std::basic_ios<char, std::char_traits<char> >, o il suo
piu` conciso sinonimo std::ios, se non vuoi darti la briga
di ragionare se quel che ti serve dipenda o meno dai vari
parametri di template, ma io ho preso l'abitudine di usare
std::ios_base dove esso e` sufficiente (una cosa in meno da
rivedere quando passo da ISO-8859-1 a Unicode o viceversa).
Alex

 conoscere anche a noi, ti prego!
No, no, era una battuta semplicemente per dire che non ci ho capito
molto di quell'esempio, anche perché non riesco a compilarlo (come ti ho
scritto in un altro messaggio).
EMG
PS. Comunque ecco una mia versione:
void leggitutto(std::istream& ist, std::string& result)
{
    std::ostringstream ost;
    ost << ist.rdbuf();
    result = ost.str();
}
Che ne pensi?
PPS. Cercando di fare questa ho anche capito meglio la tua.

 PPS. Cercando di fare questa ho anche capito meglio la tua.
Bene, ne sono contento!
Alex

 argomento streambuf*, che e` il punto-chiave della faccenda:-).
Quindi, se ho capito bene, sostituendo
result = ost.str();
con
result.swap( ost.str() );
ottengo prestazioni paragonabili al tuo metodo?
EMG

 ottengo prestazioni paragonabili al tuo metodo?
In teoria si`; non c'e` ragione di aspettarsi differenze
sostanziali (l'overhead di creare un'intera stringstream
piuttosto che solo lo stringbuf e` minuscolo a fronte dei
costi delle operazioni di I/O in quantita` importanti).
Alex


A mio avviso per questo problema č piů adatta una procedura
di basso livello (senza fronzoli)
#include <fcntl.h>
#include <io.h>
#include <iostream>
int main()
{
  int fd = open("filename", O_RDONLY);
  size_t file_size = lseek(fd, 0, SEEK_END);
  char* buffer = new char[file_size + 1];
  lseek(fd, 0, SEEK_SET);
  read(fd, buffer, file_size);
  buffer[file_size] = '\0';
  std::cout << buffer << '\n';
  delete[] buffer;
}
N.B.
usa il file-system tipo UNIX che non č standard
(anche se non capisco il perchč) ma č praticamente
presente in tutti i compilatori.
Infatti l'uso di istream comporta sempre una lettura del file
pezzo a pezzo;
in questo modo, invece, il file viene letto
tramite una sola chiamata di sistema.

 tramite una sola chiamata di sistema.
Non necessariamente.  In questo caso, stai dando per
scontata non solo l'esistenza di certe estensioni non
standard, ma anche la loro efficienza.
Se proprio occorre usare funzioni non standard, allora
badando veramente all'efficienza e` probabilmente
meglio passare alle funzioni di memory-mapping (che
sono presenti, in diverse forme, nei vari sistemi
operativi moderni).  In presenza di memoria virtuale,
perche` fare due passaggi disco->memoria->memoria,
quando il memory-mapping te lo risparmia?
Alex