Guida Linguaggio C: L'Output su File
14 Gennaio 2008 C
   





Output su File

Le istruzioni per l'output da file sono le seguenti

Output verso File
Funzione Descrizione
int putc(int c, FILE *stream) Scrive un carattere nello stream indicato.
int fputc(int c, FILE *stream) Produce gli stessi effetti della putc.
int fputs(const char *s, FILE *stream); Scrive una stringa sul file.
int fprintf(FILE *stream, const char *formato, ...) Scrive una stringa sul file formattandola come indicato nella stringa di formattazione.
size_t fwrite (const void *ptr, size_t dim, size_t n, FILE *stream); Scrive nel file n elementi ciascuno di dimensione pari a dim byte prelevandoli dall'area di memoria puntata da ptr.


putc

La funzione putc scrive un carattere in uno stream. Scrive il carattere contenuto in c nello stream puntato da stream. Restituirà il carattere scritto se l'operazione di scrittura si è svolta correttamente, altrimenti restituirà EOF.

  1. #include <stdio.h>
  3. int putc(int c, FILE *stream)

Esempio
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. FILE *f;
  5. char filename[60];
  6. int c;
  7.  
  8. int main()
  9. {
  10. f = fopen(filename, "w");
  11.  
  12. if (f == NULL) printf("Errore nell'apertura del file");
  13. else
  14. {
  15. printf("Inserire il Testo\n");
  16. do
  17. {
  18. c = getchar();
  19. putc(c, f);
  20. } while (c != 32);
  21.  
  22. fclose(f);
  23. }
  24. return 0;
  25. }

Si apre il file indicato in scrittura, quindi si leggono i dati inseriti da tastiera e li si scrive sul file. I dati inseriti non verranno scritti su file fino a quando non si premerà enter. I dati letti saranno inseriti fino a quando non si digiterà il carattere spazio (codice ascii 32).

fputc

La funzione fputc scrive un carattere su un file. Riceve un intero, lo converte in un unsigned char e lo scrive sul file. L'indicatore della posizione del file viene fatto avanzare di una posizione.
Se la scrittura ha avuto successo restituisce il carattere scritto, altrimenti restituisce EOF.

  1. #include <stdio.h>
  2.  
  3. int fputc(int character, FILE *stream);

Esempio
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. FILE *f;
  5. char filename[60];
  6. int c;
  7.  
  8. int main()
  9. {
  10. f = fopen(filename, "w");
  11.  
  12. if (f == NULL) printf("Errore nell'apertura del file");
  13. else
  14. {
  15. printf("Inserire il Testo\n");
  16. do
  17. {
  18. c = getchar();
  19. fputc(c, f);
  20. } while (c != 32);
  21.  
  22. fclose(f);
  23. }
  24. return 0;
  25. }

Si apre il file indicato in scrittura, quindi si leggono i dati inseriti da tastiera e li si scrive sul file. I dati inseriti non verranno scritti su file fino a quando non si premerà enter. I dati letti saranno inseriti fino a quando non si digiterà il carattere spazio (codice ascii 32).

fputs

La funzione fputs scrive la stringa puntata da str nel file. A differenza della puts non scrive il carattere newline alla fine della stringa.
Se la scrittura ha avuto successo restituisce un numero non negativo, altrimenti restituisce EOF.

  1. #include <stdio.h>
  2.  
  3. int fputs(const char *str, FILE *stream);

Esempio
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. FILE *f;
  5. char filename[60];
  6. char buffer[100];
  7.  
  8. int main()
  9. {
  10. f = fopen(filename, "w");
  11.  
  12. if (f == NULL) printf("Errore nell'apertura del file");
  13. else
  14. {
  15. printf("Inserire il Testo\n");
  16. do
  17. {
  18. gets(buffer);
  19. if (strstr(buffer, "fine") == NULL)
  20. {
  21. fputs(buffer, f);
  22. putc('\n',f);
  23. }
  24. } while (strstr(buffer, "fine") == NULL);
  25.  
  26. fclose(f);
  27. }
  28. return 0;
  29. }

Viene letta una sequenza di caratteri da tastiera che viene posta in un array di caratteri e quindi scritta sul file indicato tramite la fputs fino a quando non viene inserita la parola fine che non viene scritta nel file destinazione.
Da notare come, dopo la scrittura della stringa letta da tastiera, si è scritto sul file un carattere newline, dal momento che la fputs non aggiunge il carattere newline alla fine della stringa scritta.

fprintpf

La funzione fprintf scrive sul file la stringa formattandola come indicato nella stringa di formattazione. Se l'operazione di scrittura ha avuto successo restituisce il numero di caratteri scritti, altrimenti restituisce un valore negativo.
Per quanto riguarda le specifiche di conversione vedere quanto scritto per la scanf e la printf.

  1. #include <stdio.h>
  2.  
  3. int fprintf(FILE *stream, const char *format, ...);

Esempio
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. FILE *f;
  5. char filename[60];
  6. char cognome[25], nome[25];
  7. int eta, i;
  8.  
  9. int main()
  10. {
  11. f = fopen(filename, "w");
  12.  
  13. if (f == NULL) printf("Errore nell'apertura del file");
  14. else
  15. {
  16. for(i = 0; i <= 2; i++)
  17. {
  18. puts("Inserire Nome, Cognome, Età");
  19. scanf("%s %s %d",&nome, &cognome, &eta);
  20. fprintf(f, "%s %s %d\n",nome, cognome, eta);
  21. }
  22.  
  23. fclose(f);
  24. }
  25. return 0;
  26. }

Vengono letti alcuni elementi (nome, cognome, età), da tastiera tramite la scanf quindi vengono scritti sul file tramite la fprintf.

fwrite

La funzione fwrite scrive nel file fino a n elementi, ciascuno di dimensione pari a dim byte, contenuti nell'area puntata da ptr. L'indicatore della posizione del file viene fatto avanzare di una quantità pari al numero di byte scritti, ovvero (dim * n) byte.
Se l'operazione di scrittura ha avuto successo restituisce il numero di elementi scritti, altrimenti restituisce un numero inferiore.

  1. #include <stdio.h>
  3. size_t fwrite (const void *ptr, size_t dim, size_t n, FILE *stream);

Esempio
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. const int num_elementi = 3;
  5. struct dati
  6. {
  7. char cognome[25], nome[25];
  8. int eta;
  9. char sesso;
  10. };
  11.  
  12. typedef struct dati dati;
  13.  
  14. FILE *f;
  15. char filename[60];
  16. size_t res;
  17. int i;
  18. dati datip[3];
  19.  
  20. int main()
  21. {
  22. printf("Inserire il nome del file\n");
  23. gets(filename);
  24.  
  25. f = fopen(filename, "r");
  26.  
  27. if (f == NULL) printf("Errore nell'apertura del file");
  28. else
  29. {
  30. for(i = 0; i <= num_elementi-1; i++)
  31. {
  32. puts("Inserire Nome, Cognome, Età, Sesso");
  33. scanf("%s %s %d %c",&datip[i].nome, &datip[i].cognome, &datip[i].eta,
  34. &datip[i].sesso);
  35. }
  36.  
  37. fwrite(datip, sizeof(dati), num_elementi, f);
  38.  
  39. fclose(f);
  40. }
  41.  
  42. int ch = getchar();
  43.  
  44. return 0;
  45. }

Si scrivono nel file 3 blocchi di dati di sizeof(dati) byte di dimensione ciascuno prelevandoli da datip.
Ciascun blocco viene interpretato come una struttura di tipo dati.
 
Guida Linguaggio C