Newsgroup: it.comp.lang.c++
Titolo: come si leggono gli spazi?

Qualcuno mi spiega come devo fare per leggere gli spazi?
Sto facendo un semplice programma per copiare un file in un altro, ma
non riesco a fargli leggere gli spazi e i caratteri di fine linea...
Aiutatemi, please
P.S. Potete postarmi la risposta anche via mail? 
veg...@yahoo.com

P.S. Potete postarmi la risposta anche via mail? 
veg...@yahoo.com
Non è consuetudine, comunque fatto.
A presto,
Angelo.

 }
ERRORE ERRORE ERRORE
Dalle FAQ di comp.lang.c:
 
12.2:   Why does the code
 
                while(!feof(infp)) {
                        fgets(buf, MAXLINE, infp);
                        fputs(buf, outfp);
                }
 
        copy the last line twice?
 
A:      In C, EOF is only indicated *after* an input routine has tried
        to read, and has reached end-of-file.  (In other words, C's I/O
        is not like Pascal's.)  Usually, you should just check the
        return value of the input routine (fgets() in this case); often,
        you don't need to use feof() at all.
 
        References: K&R2 Sec. 7.6 p. 164; ANSI Sec. 4.9.3, Sec. 4.9.7.1,
        Sec. 4.9.10.2; ISO Sec. 7.9.3, Sec. 7.9.7.1, Sec. 7.9.10.2; H&S
        Sec. 15.14 p. 382.
-- 
Maurizio Loreti                      
http://wwwcdf.pd.infn.it/~loreti/mlo.html
Un. of Padova, Dept. of Physics - Padova, Italy          
lor...@padova.infn.it

non riesco a fargli leggere gli spazi e i caratteri di fine linea...
Se stai usando le funzioni Standard C++ per leggere quel
file, probabilmente ti stai "scontrando" col bit di formattazione
std::ios_base:: skipws (o suo piu`-o-meno equivalente nelle
versioni pre-standard delle librerie); questo bit, se settato (e
per molti stream lo e` di default), dice allo stream (o magari
al suo streambuf, ma da fuori non si vede la differenza) di
"saltare" (skip) lo "spazio bianco" ("ws" = "whitespace") in
varie situazioni; il "whitespace" in questione comprende i fine-riga
oltre agli spazi (e ai tab).
Nello standard C++, puoi "spegnere" questo bit con il
manipolatore (using namespace std, per intenderci...):
    ios_base& noskipws(ios_base& str);
Ricorda che ios_base e` la base da cui derivano tutti gli
stream, sia di input sia di output, sia per caratteri ANSI
sia Unicode, eccetera, per cui questa puoi applicarla a
tutti, sia nella forma elementare, del tipo:
        noskipws(cin);
sia anche, naturalmente, nella forma di operatore:
        cin >> noskipws;
quest'ultima anche, se vuoi, in una sequenza di >>.
Puoi, naturalmente, ripristinare lo skipping del whitespace,
in qualsiasi momento, con l'analogo manipolatore skipws.
Il modo di gran lunga piu` rapido di copiare uno stream
su di un altro, in C++ Standard, si appoggia pero` sugli
streambuf, la parte piu` misconosciuta e peggio nota
dell'architettura di iostream.
    cin >> cout.rdbuf();
e
    cout << cin.rdbuf();
sono due modi equivalenti, e sarebbe una libreria proprio
del cavolo quella che non li ottimizzasse!-), per copiare
tutto quanto resta della sequenza di standard input (sino
a fine file, o ad un eventuale errore di I/O) sulla sequenza
di standard output.  Io esemplifico con cin e cout, ma
tutte queste cose puoi applicarle a qualsiasi stream, ricorda!
Un "programma per copiare un file in un altro", usando
Standard C++, sarebbe dunque, ad esempio:
#include <fstream>
int main(int argc, char* argv[])
{
    if(argc != 3) return 1;
    std::ifstream fin(argv[1]);
    if(!fin) return 2;
    std::ofstream fou(argv[2]);
    if(!fou) return 3;
    fin >> fou.rdbuf();
    if(fin.bad() || fin.fail()) return 4;
    if(fou.bad() || fou.fail()) return 5;
    return 0;
}
Questo si chiama con esattamente due argomenti,
i nomi dei file da leggere e da scrivere, esce con un
diverso codice d'errore a fronte di vari problemi, e,
se non ci sono errori, copia i file ed esce con successo.
Questo programma, benche` semplicissimo, ha in
comune con i programmi "veri" il fatto che dedica la
gran parte del suo lavoro a verificare e diagnosticare
vari errori che potrebbero essere successi; quindi,
anch'esso, come i programmi "veri", puo` essere
utilmente semplificato appoggiandosi alle "exception"
del C++ Standard.
    if(argc != 3) return 1;
    std::ifstream fin(argv[1]);
    fin.exceptions(ios::bad||ios::fail);
    std::ofstream fou(argv[2]);
    fou.exceptions(ios::bad||ios::fail);
    fin >> fou.rdbuf();
    return 0;
Questo puo` essere sufficiente, oppure si puo`
usare un blocco try/catch per dare una diagnostica
diversa da quella offerta dalle "uncaught exceptions".
Il punto e` che gli stream non lanciano eccezioni
_per default_, ma si puo` abilitarle con l'apposita
funzione-membro exceptions -- e chiamando questa
funzione si ottiene gia` un'exception se lo stato dello
stream e` gia` in quel momento "danneggiato" dai
vari possibili errori.
Alex

 Aiutatemi, please


        copy the last line twice?
Mi permetto di fare osservare che questo pezzo di codice non funziona
perche' non viene effettuato alcun test dopo la "fgets" (fine file oppure un
altro tipo di errore) e non tanto perche' viene controllato "eof" nella
condizione del "while".
Comunque ti ringrazio per la precisazione.
A presto,
Angelo Donatiello.