- Quan llegim caràcters amb getchar() o escrivim informació de text amb printf(), se suposa que ho hem de fer a través del teclat i la pantalla. De vegades, però, la informació a introduir o visualitzar és massa extensa com per teclejar-la "a mà" o veure-la en pantalla. En aquests casos és interessant poder "xuclar" o gravar la informació usant fitxers, però sense canviar el programa. Això és possible gràcies al concepte de canals d'informació. El programa llegeix o escriu informació als canals, i el S.O. s'encarrega de "transportar" aquesta informació als dispositius adients.
- Els canals d'entrada i sortida estàndard estan "connectats", per defecte, al teclat i a la pantalla. Si quan instanciem un programa des de l'intèrpret de comandes especifiquem que els canals d'entrada o de sortida són fitxers, el S.O. s'encarregarà d'obrir els fitxers i transferir la informació entre aquests i el programa. En altres paraules, el programa no sap si llegeix de teclat o de fitxer, només sap que llegeix del canal estàndard d'entrada.
ex 4.1: El programa calcula el número de línies, paraules i caràcters que s'introdueixen per l'entrada estàndard i imprimeix els resultats per la sortida estàndard. Per detectar línies busca el caràcter fi de línia '\n'. Per detectar paraules es defineix un booleà (int estat) que recorda si estava llegint una paraula quan troba un espai en blanc, un fi de línia o un tabulador ('\t'):
#include <stdio.h>
#define DINTRE 1 /* dintre d'una paraula */
#define FORA 0 /* fora d'una paraula */
/* compta línies, paraules i caràcters de l'entrada */
void main(void)
{
int c, nl, np, nc, estat;
estat = FORA;
nl = np = nc = 0;
while ((c = getchar()) != EOF) {
++nc;
if (c == '\n') ++nl;
if (c == ' ' || c == '\n' || c == '\t') estat = FORA;
else if (estat == FORA) { estat = DINTRE;
++np;
}
}
printf("línies:%d\nparaules:%d\ncaràcters:%d\n",nl,np,nc);
}
- Per practicar amb aquests conceptes disposem del fitxer COMPTAPR.C al directori SEC4. Si el compileu i l'executeu, haureu d'introduir un cert número de línies de text seguides d'un caràcter '^Z' (tecla Ctrl + Z), més un <Return>, per simular un fi de fitxer (EOF):
C:\...\> COMPTAPR la mar estaba salada salada estaba la mar mar serena... ^Z línies : 3 paraules : 12 caràcters : 52
Per redireccionar el canal d'entrada a un fitxer, des de l'intèrpret de comandes escriviu el nom del programa més un nom de fitxer precedit pel caràcter '<'. Per exemple, comptem les línies, paraules i caràcters del fitxer COMPTAPR.C:
C:\...\> COMPTAPR <COMPTAPR.C línies : 35 paraules : 148 caràcters : 1173
Per redireccionar el canal de sortida a un fitxer, des de l'interpret de comandes escriviu el nom del programa més un nom de fitxer precedit pel caràcter '>'. Per exemple, comptem les línies, paraules i caràcters del teclat i escriviu els resultats sobre el fitxer RESULT.TXT (el crearà en aquell moment). Després visualitzarem el fitxer de resultats amb TYPE:
C:\...\> COMPTAPR >RESULT.TXT la mar estaba salada salada estaba la mar mar serena... ^Z C:\...\> TYPE RESULT.TXT línies : 3 paraules : 12 caràcters : 52
També podem combinar els dos redireccionaments:
C:\...\> COMPTAPR <COMPTAPR.C >RESULT2.TXT
- Una de les possibilitats més interessants del redireccionament de canals és la de transferir informació entre els perifèrics de l'ordinador i el programa (sense canviar el codi del programa). Podem, per exemple, llegir el text del port sèrie i escriure el resultat en la impressora:
C:\...\> COMPTAPR <COM1: >PRN:
- Per accedir als fitxers directament des de programa disposem d'una sèrie de funcions estàndard, les definicions de les quals es troben al Header STDIO.H. Algunes de les més importants són:
| tipus: | defines: |
FILE |
EOF |
| funcions d'operació de fitxers: | funcions d'entrada/sortida sobre fitxers: |
fopen(); fclose(); fread(); fwrite(); fseek(); feof(); ferror(); |
fprintf(); fscanf(); fgetc(); fputc(); fgets(); fputs(); |
ex 4.2: El programa DEFINES.C implementa un algorisme que imprimeix les línies d'un fitxer que comencin per la paraula clau "#define":
#include <stdio.h>
#include <string.h>
void main(void)
{
char lin[80];
FILE *fit;
printf("Nom d'un fitxer : "); scanf("%s",lin);
fit = fopen(lin,"r");
if(fit==NULL) printf("Error obrint fitxer\n");
else
{
while (!feof(fit));
{
fgets(lin,80,fit);
if(strncmp(lin,"#define",7)==0) printf("%s",lin);
}
fclose(fit);
}
}
- El procediment normal per operar amb fitxers és cridar a la funció fopen(), que rep com a paràmetres el nom del fitxer a disc que es vol obrir (nom físic) i el mode d'accés al fitxer ("r" llegir, "w" escriure, etc.), i retorna un apuntador a una estructura FILE, que serà emmagatzemada sobre una variable de programa, i que serà aquesta variable la que es farà servir per identificar el fitxer en totes les altres funcions (nom lògic). Si no ha pogut obrir el fitxer retorna un punter NULL.
- La resta de funcions d'operació permeten llegir buffers (blocs) de caràcters, escriure buffers, posicionament dins del fitxer, detecció de fi de fitxer, detecció d'errors i tancament de fitxer. És important no oblidar-nos de tancar tots els fitxers abans de sortir del programa, per no perdre informació.
- Les funcions d'entrada/sortida sobre fitxers són les mateixes que les d'entrada i sortida típiques (printf(), gets(), etc.) però aquesta vegada la informació es transfereix al fitxer indicat (s'ha de passar per paràmetre el punter a FILE corresponent). De fet es pot considerar a les típiques com un cas particular de les de fitxers, ja que les primeres accedeixen als punters a "fitxers" d'entrada i sortida estàndard.
- A partir del fitxer DEFCON2.C, implementeu un programa que imprimeixi la llista de línies d'un fitxer d'entrada que comencin per una paraula clau que introduirà l'usuari. A més, l'usuari podrà introduir els noms dels fitxers d'entrada i de sortida per la línia de comandes del S.O., és a dir, pas de paràmetres a la funció main(). Si entra un paràmetre, es tracta del nom del fitxer d'entrada. Si hi han dos paràmetres, són el fitxer d'entrada i el de sortida:
#include <stdio.h>
#include <string.h>
int main(int nc, char *targ[])
{
char lin[80]; /* per llegir linies de texte */
FILE *fit_e, *fit_s;
if(nc==1) /* no s'han introduit paràmetres */
{
printf("introdueix almenys 1 paràmetre\n");
return(1);
}
else
{
fit_e = fopen(targ[1],"r");
if(fit_e==NULL)
{
printf("Error obrint fitxer\n");
return(2);
}
else
{
if(nc>2) /* hi ha més d'un paràmetre */
{
fit_s = fopen(targ[2],"w");
/* etc...*/
}
}
}