 |
|
|
 |
|
|
|
04 - Flussi di dati
Per flusso si intende una entit� sulla quale � possibile leggere e scrivere dei dati. Esempi di flusso possono essere:
- Un file: � l'esempio per eccellenza: il file permette di immagazzinare dei dati, e di leggerli.
- Una pipe: � una entit� astratta allocata dal sistema operativo, e pu� essere vista come una sorta di contenitore temporaneo per i dati: un processo pu� scrivere dei dati in una pipe, e un altro processo pu� leggere questi dati. Viene cio� utilizzata per scambiare dati tra i processi.
- standard input e standard output: indicati comunemente con STDIN e STDOUT, sono dei flussi particolari, utilizzati per ottenere l'input e l'output di un processo. Per un processo a riga di comando, tipicamente STDIN � tutto ci� che viene battuto sulla tastiera. STDOUT � tutto ci� che viene scritto sullo schermo.
In questa sezione sono presentate alcune funzioni che permettono di creare, leggere, scrivere e chiudere flussi di dati, come quelli provenienti da file o da altre entit� come la pipe. Le funzioni sono contenute nelle librerie fcntl.h e unistd.h.
- open(char *nome_file, flag): la funzione restituisce un descrittore di file fd, un intero che identifica il flusso aperto. Il flusso fa riferimento a nome_file, che pu� essere un file effettivamente presente sul disco, oppure un'altra entit�. flag identifica i permessi del flusso.
- read(int fd, void *buf, size_t count): la funzione legge count byte dal descrittore di file fd nel buffer buf.La funzione ritorna il numero di byte effettivamente letti.
- write(int fd, void *buf, size_t count): la funzione scrive count byte sul descrittore di file fd presi dal buffer buf.La funzione ritorna il numero di byte effettivamente scritti.
- close(int fd): chiude il descrittore di file fd.
- pipe(int vettore_pipe[2]): la funzione crea un flusso di tipo pipe. Tale flusso pu� essere letto e scritto utilizzando il vettore vettore_pipe[2]. In particolare, l'elemento vettore_pipe[0] serve come descrittore di file per la lettura, mentre vettore_pipe[1] serve come descrittore di file per la scrittura.
/* Il seguente programma crea due processi, padre e figlio, in comunicazione
tra loro tramite una pipe. Il padre legge dei dati da STDIN, cio� dalla
tastiera, li scrive sulla pipe, attende che il figlio li abbia ricevuti e
processati, e termina. Il figlio attende i dati dal padre.
Quando questi vengono scritti sulla pipe, li legge, li visualizza
a schermo, cio� su STDOUT, invia al padre il segnale di avvenuta ricezione
e poi termina.
*/
#include<stdio.h>
#include<fcntl.h>
#include <unistd.h>
#include<signal.h>
void fine()
{
}
char buf[21];
int fd_pipe[2], byte_letti;
void main()
{
int PID_padre, PID_figlio;
// Creazione della pipe
pipe(fd_pipe);
if( (PID_padre=fork()) == 0)
{ // Figlio
// Attesa dei dati
wait();
// Lettura delle pipe
close(fd_pipe[1]);
read(fd_pipe[0], buf,21);
close(fd_pipe[0]);
printf("\n ** Figlio: dati ricevuti dal padre: %s\n", buf);
// Avvisa il padre della ricezione dei dati
kill(getppid(), SIGUSR1);
}
else if(PID_figlio>0)
{ // Padre
// Lettura dei dati dallo schermo
printf("\nInserire il codice (max 20 caratteri):\n");
byte_letti = read(0,&buf,21);
printf("Caratteri inseriti: %i ", byte_letti-1);
printf("\nCodice inserito: \n");
write(1,buf,byte_letti-1);
printf("\n");
// Invio dei dati al figlio tramite pipe
close(fd_pipe[0]);
write(fd_pipe[1], buf, byte_letti-1);
close(fd_pipe[1]);
// Attende la fine del figlio
signal(SIGUSR1, fine);
pause();
}
else
{
printf("Errore nella creazione del figlio.");
//exit(-1);
}
}
Fatal error: Call to undefined function sqlite_open() in /membri/giacobbe85/include/commenti.inc.php on line 324
|
| |
