Newsgroup: it.comp.lang.c++
Titolo: operazioni su file o su terminali

Qual'č la differenza tra operazioni effettuate su file e operazioni
effettuate su terminale?
Dove per terminale io intendo una tastiera e un monitor collegate ad un
host.
Mentre per file (in C/C++) intendo indicare un'astrazione logica che viene
applicata a qualsiasi dispositivo fisico.
Forse un operazione su terminale non implica il SO? mentre un'operazione su
file implica il SO? Bhoo..!
Indicatemi la retta via per favore!
Grazie

 Qual'è la differenza tra operazioni effettuate su file e operazioni

per quanto ne so io le cose funzionano cosi':
stdin, stdout e stderr che si utilizzano per accedere al terminale
non sono altro che istanze del tipo FILE * (puntatore a FILE), per cui
nel linguaggio C/C++ il video e la tastiera sono visti come particolari file.
A titolo di esempio riporto alcune dichiarazioni che si trovano nel file
stdio.h che includo nei miei programmi (io uso Linux su Pentium con compilatore
GNU. Il file stdio.h si trova in genere in /usr/include);
typedef struct _IO_FILE FILE;
extern FILE *stdin, *stdout, *stderr;
La struttura _IO_FILE e' dichiarata nel file libio.h, incluso da stdio.h  e
ne riporto piu' avanti la dichiarazione.
Se tu usi  ad esempio istruzioni come la seguenti:
   printf("questa e' una prova");
   fflush(stdout); /* forza il flushing del buffer sul "file" individuato da
                      stdout, cioe' sul video */
per quanto ne so io, la printf esegue internamente una
   fprintf(stdout,"questa e' una prova"); /* scrive nel buffer "interno" */
cioe' in pratica scrivere su video e' come scrivere sul file "identificato"
dal puntatore a FILE stdout.
Analogamente avviene per la lettura da tastiera (per quanto ne so io e' analoga
alla lettura dal particolare file "identificato" dal puntatore stdin);
Il programmatore non deve preoccuparsi di aprire e/o chiudere i file
individuati da stdin, stdout, stderr; questo viene fatto automaticamente.
Il programmatore deve solo ricordarsi di includere l'header stdio.h nel
suo codice se vuole usare stdin, stdout, stderr.
 struct _IO_FILE {
#ifdef __SVR4_I386_ABI_L1__
  /* The following pointers correspond to the C++ streambuf protocol. */
  char* _IO_read_ptr;   /* Current read pointer */
  char* _IO_read_end;   /* End of get area. */
  char* _IO_read_base;  /* Start of putback+get area. */
  int _flags;           /* High-order word is _IO_MAGIC; rest is flags. */
#else
  int _flags;           /* High-order word is _IO_MAGIC; rest is flags. */
  /* The following pointers correspond to the C++ streambuf protocol. */
  char* _IO_read_ptr;   /* Current read pointer */
  char* _IO_read_end;   /* End of get area. */
  char* _IO_read_base;  /* Start of putback+get area. */
#endif
  char* _IO_write_base; /* Start of put area. */
  char* _IO_write_ptr;  /* Current put pointer. */
  char* _IO_write_end;  /* End of put area. */
  char* _IO_buf_base;   /* Start of reserve area. */
  char* _IO_buf_end;    /* End of reserve area. */
  /* The following fields are used to support backing up and undo. */
  char *_IO_save_base; /* Pointer to start of non-current get area. */
  char *_IO_backup_base;  /* Pointer to first valid character of backup area */
  char *_IO_save_end; /* Pointer to end of non-current get area. */
  struct _IO_marker *_markers;
  struct _IO_FILE *_chain;
  int _fileno;
  int _blksize;
  _IO_off_t _offset;
#define __HAVE_COLUMN /* temporary */
  /* 1+column number of pbase(); 0 is unknown. */
  unsigned short _cur_column;
  char _unused;
  char _shortbuf[1];
  /*  char* _save_gptr;  char* _save_egptr; */
  struct _IO_lock_t _IO_lock;
};
Io ho riportato questa struttura a titolo di esempio, ma per quanto ne so
io ogni compilatore e' libero di implementare come vuole le proprie strutture
interne. Cioe' per quanto ne so io, e' necessario e sufficiente che il
compilatore renda visilbili al programmatore cio' che e' previsto dallo
standard del linguaggio. In questo caso basta che il programmatore abbia
la possibilita' di dichiararsi dei propri puntatori di tipo
FILE * e utilizzare stdin, stdout e stderr. Non c'e' nessun motivo per cui
un programmatore debba "vedere" una struttura come la _IO_FILE (a meno
che non sia prevista dallo standard, ma per quanto ne so io non lo e').
In altre parole se un programmatore scrive
...
  FILE *fp = fopen("f.dat","w");
...
questa linea di codice dovrebbe essere accettata da tutti i compilatori
conformi allo standard, mentre una linea del tipo
...
  struct _IO_FILE *fp = fopen("f.dat","w");
...
viene compilata correttamente solo su sistemi in cui la struttura FILE
e' implementata per mezzo della _IO_FILE come nel mio sistema,
ma nessuno garantisce che su tutti i sistemi la struttura file sia
implementata cosi (ripeto: a meno che non sia previsto dallo standard, ma
per quanto ne so io lo standard lascia una certa liberta' nella
implementazione delle strutture interne).
Spero di essere stato chiaro
Marco Guidi.
 

Tutto OK..!
Sei stato chiarissimo.
Attendo cmq altri pareri.
Mille grazie per l'attenzione.

 host.
Non dovrebbe esserci alcuna differenza per la libreria standard.
EMG

 nel linguaggio C/C++ il video e la tastiera sono visti come particolari file.
E, dato che siamo su it.comp.lang.c++, anche per cin, cout, cerr è la
stessa cosa.
EMG