Programació estructurada i modular Unitat didàctica 5 - Dextrus

CICLES FORMATIUS
Família Professional Informàtica
Cicle formatiu de grau superior
DESENVOLUPAMENT D’APLICACIONS INFORMÀTIQUES
Crèdit 5
Programació estructurada i modular
Unitat didàctica 5: Gestió de fitxers
Albert Canela Campos

Índex
5.1 Fitxers a C ......................................................................................................................................3
5.1.1 Fitxers de text i fitxers binaris ................................................................................................3
5.1.2 Declaració d'un arxiu ..............................................................................................................4
5.1.3 Obertura d'un arxiu .................................................................................................................4
5.1.4 Tancament d’un arxiu .............................................................................................................6
5.2 Fitxers de text.................................................................................................................................7
5.2.1 Escriptura i lectura de caràcters. Les funcions fgetc() i fputc() ..............................................7
5.2.2 Lectura i escriptura amb les funcions fgets() i fputs().............................................................9
5.2.3 Lectura i escriptura de dades formatades. Les funcions fprintf() i fscanf() ..........................12
5.2.4 L’accés directe ......................................................................................................................15
Exercicis.....................................................................................................................................17
Pràctica...............................................................................................................................................19
5.3 Fitxers binaris...............................................................................................................................20
Exercici ......................................................................................................................................24
Pràctica...............................................................................................................................................25
2

5.1 Fitxers a C
El sistema d'entrada i sortida de C proporciona un sistema independent del dispositiu físic en el
qual, o des del qual, es realitzin les operacions. Aquest sistema independent és una abstracció de
dispositiu que rep el nom de flux o corrent (en anglès stream). De fet, només necessitem considerar
un arxiu com un flux de dades que circulen en un o altre sentit.
Tècnicament, quan s'obre un arxiu per utilitzar funcions d'entrada i sortida, aquest arxiu s'associa
amb una estructura del tipus FILE (definit a stdio.h). Aquesta estructura conté tota la informació
bàsica sobre l'arxiu.
5.1.1 Fitxers de text i fitxers binaris
Quan emmagatzemem dades en un fitxer, aquestes es poden emmagatzemar en format text o en
format binari. El format text significa que s’emmagatzema tot com a text, inclosos els números. En
canvi, en format binari, el que es guarda és la representació interna de la computadora per aquell
valor. Per exemple quan volem guardar un enter en un fitxer de text, es guardarà realment els
caràcters que el composen. En canvi, si aquest mateix enter es vol emmagatzemar en un fitxer
binari, enlloc d’emmagatzemar caràcters, s’emmagatzemarà la representació interna de l’ordinador,
d’aquest enter.
La representació binària acostuma a ocupar menys espai que el format de caràcters ASCII dels
mateixos valors. A més, degut a que les dades binàries normalment utilitzen menys espai en disc
que les de text, l’E/S per arxiu binari acostuma a ser més ràpida que l’E/S de text.
No obstant cada format té els seus avantatges. Així doncs, el format text és més fàcil de llegir, i el
podem editar en un editor de text, en un processador de textos, etc. A més, un arxiu binari es pot
transmetre molt fàcilment d’un ordinador a un altre. Per altra banda, el format binari és més precís
per a números, pel que fa a la no existència d’errors de precisió o d’arrodoniment.
Els arxius binaris s’han de tractar de manera diferent als de text, doncs no contenen caràcters
d’espais en blanc, les dades no estan organitzades en línies amb el caràcter d’acabament de nova
línia, etc.
3

5.1.2 Declaració d'un arxiu
Com tota variable, una variable arxiu ha de ser declarada abans d'utilitzar-la. Així, la sentència
FILE *fitxer;
declara una variable d’arxius anomenada fitxer. Aquesta variable, de fet, és un punter a l'objecte
FILE, que és una estructura definida a l'arxiu capçalera stdio.h. Per tant, és necessari incloure la
directiva #include en qualsevol programa en què s’utilitzi arxius.
5.1.3 Obertura d'un arxiu
Declarar una variable d'arxiu no és suficient per poder treballar amb ell. És necessari precisar dues
coses:
D'una banda, és imprescindible assenyalar de quin arxiu físic es tracta. És necessari donar un nom a
l'arxiu que serà el que restarà al suport magnètic.
D'altra banda, farà falta precisar el tipus de treball que volem fer: llegir, escriure,...
Aquestes característiques es donen amb l'ajuda de la funció fopen() que té la següent sintaxi:
FILE *fopen(char *nom_arxiu, char *mode)
La funció fopen() retornarà el valor NULL si no s'ha pogut obrir l'arxiu, per exemple, si el disc està
protegit o ple.
El primer argument de la funció fopen() és el nom físic de l'arxiu i permet l'associació entre el nom
físic sobre el suport (nom_arxiu) i el nom lògic de l'arxiu en el programa.
El segon argument està format per una cadena de caràcters que precisa el mode de treball amb
l'arxiu.
4

Són possibles les diferents possibilitats:
r
w
a
r+
w+
(read). Obre un arxiu només per llegir. L'arxiu ha d'existir. El cursor se situarà damunt del
primer octet de l'arxiu.
(write). Obre un arxiu només per escriure. El cursor se situarà damunt del primer octet de
l'arxiu. Si l'arxiu ja existeix es sobreescriu.
(append). Obre un arxiu per escriure. El cursor se situarà damunt de l'últim octet de l'arxiu
si aquest ja existeix, per tant, serveix per afegir dades a un arxiu. En el cas que l'arxiu no
existeixi funciona igual que w.
Obre un arxiu per llegir i escriure alhora. L'arxiu ha d'existir prèviament. El cursor se situa
al començament de l'arxiu.
Obre un arxiu per llegir i escriure alhora. Si l'arxiu existeix prèviament, s'esborra el seu
contingut.
a+ Obre un arxiu per afegir dades i per llegir. Si l'arxiu no existeix el crearà.
Quan obrim un fitxer amb “a” o bé “a+”, totes les operacions d’escriptura es duen a terme a la fi del
fitxer. Nosaltres podem reposicionar el punter del fitxer utilitzant tècniques de posicionament
directe que veurem més endavant, però cada vegada que fem un write, el punter es mou cap al final
del fitxer automàticament. D’aquesta manera s’evita que es sobreescriguin dades.
Quan especifiquem “r+”, “w+” o bé “a+”, es permet tant lectura com escriptura (es per això que a
aquests modes se’ls hi diu modes d’actualització). No obstant, quan nosaltres passem de fer una
escriptura a fer una lectura, o a l’inrevés, cal que es duguin a terme algunes operacions d’accés
directe (fseek, ftell, etc.) o de neteja de buffer (fflush), que ja veurem més endavant.
Afegint “b” a aquests modes, tractarem fitxers binaris. I serà doncs aquests modes els que
utilitzarem més a les nostres pràctiques (“rb”, “wb”, “ab”, “r+b”, etc. ).
5

5.1.4 Tancament d’un arxiu
Al final del treball sobre l'arxiu, o si més no abans de sortir del programa, és necessari tancar l'arxiu.
Aquest tancament té diferents objectius. El primer consisteix en alliberar el canal atribuït a l'arxiu i
permetre obrir un altre arxiu sense superar el màxim nombre possible d'arxius oberts al mateix
temps. El segon, i gairebé sempre el més important, és buidar el buffer (zona de memòria) associat a
l'arxiu. L'escriptura d'un arxiu no es fa directament al suport físic sinó que les diferents escriptures
són enviades a un buffer per tal d'estalviar accessos al disc que són massa lents. En cas d'acabament
normal del programa, el sistema operatiu s'encarrega de tancar els arxius, però això no sempre és
possible, per exemple quan marxa el llum, si es bloqueja l'ordinador, etc. Per tant és recomanable
cada cert interval de temps tancar i tornar-lo a obrir per evitar pèrdua de dades.
Per tancar ho farem amb la funció fclose() que té la següent sintaxi:
int fclose (FILE *nom_arxiu);
Aquesta funció torna el valor enter 0 si l'arxiu s'ha pogut tancar correctament.
6

5.2 Fitxers de text
5.2.1 Escriptura i lectura de caràcters. Les funcions fgetc() i fputc()
Creeu un nou arxiu del tipus C anomenat m5p01.c i escriviu el següent codi:
//m5p01.c - Creació, escriptura i lectura d'un arxiu -
#include
#include
int main(){
FILE *f;
char car;
//procés d'escriptura
system("cls");
if((f=fopen("arxiu.txt","w"))==NULL)
printf("Error al intentar obrir l'arxiu\n");
else{
printf("Introdueix un text. Prem return per finalitzar. \n");
}
}
while ((car=getchar())!='\n') fputc(car,f);
fclose(f);
//procés de lectura
printf("Lectura de l'arxiu\n");
if((f=fopen("arxiu.txt","r"))==NULL)
printf("Error a l'intentar obrir l'arxiu\n");
else{
while((car=fgetc(f))!=EOF) putchar(car);
putchar('\n');
fclose(f);
}
system("pause");
7

Explicació del programa
La següent sentència és una forma habitual d'obrir un arxiu:
if((f=fopen("arxiu.txt","w"))==NULL)
printf("Error al intentar obrir l'arxiu\n");
En aquest cas, s'obre un arxiu de nom arxiu.txt en mode escriptura (w). La variable f és una variable
punter del tipus FILE. L'estructura FILE està definida a l'arxiu capçalera stdio.h, per tant és
necessari incloure la directiva #include en qualsevol programa que utilitzi arxius. Si la
funció fopen() torna el valor NULL vol dir que ha trobat un error i sortirà el missatge d'error i
sortirà del programa.
La següent línia és la que s'encarrega d'escriure en el fitxer els caràcters entrats per teclat. Això és fa
sempre que el caràcter llegit del teclat amb la funció getchar() no sigui el caràcter de retorn de línia
(\n), és a dir, INTRO. La funció que s'encarrega d'enviar un caràcter al fitxer és la funció fputc(), el
primer argument d'aquesta funció és un caràcter o variable de caràcter i el segon argument és una
variable punter FILE.
Després d'escriure el text, es tanca l'arxiu amb la funció fclose(). És important tancar els arxius
fonamentalment per dues raons:
a) per a no sobrepassar el màxim nombre d'arxius oberts que suporta el sistema operatiu.
b) (gairebé sempre el més important) perquè s'escrigui al disc el que hi hagi al buffer, d'aquesta
forma no es perdrà la informació en cas que es bloquegi l'ordinador.
Per procedir a la lectura de l'arxiu, es torna a obrir aquest, en aquest cas en mode de lectura (r):
La línia:
if((f=fopen("arxiu.txt","r"))==NULL)
printf("Error al intentar obrir l'arxiu\n");
while((car=getc(f))!=EOF) putchar(car);
és la que llegeix un caràcter del fitxer (amb la funció getc()) fins que trobi la marca EOF de final
d'arxiu i escriu el caràcter llegit a la pantalla amb la funció putchar().
8

Les quatre funcions d'entrada i sortida tractades en aquesta pràctica són:
fgetc() Llegeix un caràcter d'un arxiu.
getchar() Llegeix un caràcter de l'entrada estàndard (teclat).
fputc() Escriu un caràcter en un arxiu.
putchar() Escriu un caràcter a la sortida estàndard (pantalla).
5.2.2 Lectura i escriptura amb les funcions fgets() i fputs()
Les funcions fgets() i fputs() permeten llegir i escriure cadenes de caràcters en els arxius
prèviament oberts amb la funció fopen().
La sintaxi de la funció fgets() és:
char *fgets( char *cadena, int rang, FILE *punter_arxiu)
La funció fgets() retorna la cadena llegida en cas que la lectura hagi estat correcta, o bé NULL si no
ha estat possible. El primer argument és un punter al lloc de destí de la cadena que volem llegir. La
lectura s’aturarà quan s’hagi llegit un total de rang-1 caràcters o quan trobem el caràcter de nova
línia. Llavors, quan es dóna una d'aquestes dues condicions, fgets() afegeix el caràcter '\0' (nul) de fi
de cadena. Si la cadena que estem llegint finalitza amb el caràcter de nova línia '\n', llavors la
cadena contindrà el caràcter de nova línia i després el finalitzador de cadena '\0' (nul).Si es produeix
un error, la funció fgets() retornarà la constant de caràcter NULL.
La funció fputs() té per sintaxi:
int fputs( char *str, FILE *punter_arxiu )
i tramet una cadena de caràcters a l'arxiu apuntat pel punter punter_arxiu que és un punter de tipus
FILE. Si es produeix un error, retorna la constant EOF de final d'arxiu. No afegeix el caràcter de
nova línia en la sortida. Retorna l'últim caràcter escrit o el caràcter de final d’arxiu EOF.
9

Per practicar aquestes dues funcions, escriviu el següent codi:
Creeu un nou arxiu del tipus C anomenat m5p02.c i escriviu el següent codi:
// m5p02.c - Lectura i escriptura amb fgets() i fputs() -
#include
#include
int main(){
FILE *punter;
char cadena[80];
if (( punter = fopen ("fitxers.txt","w"))==NULL)
puts("\nNo puc crear l'arxiu fitxers.txt");
else{
printf("Introduiu text de varies linies.\n");
printf("Una linia en blanc per acabar.\n");
while (strlen(fgets(cadena,80,stdin))!=1)
fputs(cadena,punter);
fclose(punter);
}
// lectura
if (( punter = fopen ("fitxers.txt","r"))==NULL)
puts("\nNo puc crear l'arxiu: fitxers.txt");
else{
while (fgets(cadena,80,punter) != NULL)
printf("%s",cadena);
fclose(punter);
}
system("pause");
}
10

Explicació del programa
La lectura es fa amb la sentència:
while (strlen(fgets(cadena,80,stdin)) !=1){
fputs(cadena,punter);
}
Aquesta és una sentència típica de C on es barregen funcions i expressions. La funció fgets() llegeix
una cadena de l'entrada estàndard (teclat) i torna el seu argument si no hi ha hagut cap error, és a
dir: strlen(fgets(cadena,80,stdin)) és equivalent a: strlen(cadena). La funció fgets() manté el
caràcter de nova línia (\n), per tant, si s'introdueix una cadena buida,
strlen(fgets(cadena,80,stdin))) és igual a 1, i per tant surt del bucle while. Mentre la cadena no
sigui buida, escriu el contingut de la cadena de caràcters cadena en l'arxiu apuntat pel punter.
La part de lectura es fa de forma similar,
while (fgets(cadena,80,punter) != NULL)
printf("%s",cadena);
fclose(punter);
La funció fgets() llegeix de l'arxiu apuntat per punter una línia o fins a 80 caràcters i emmagatzema
aquests caràcters en la variable cadena. Aquesta lectura es fa mentre el valor retornat per la funció
no sigui NULL. Aquesta circumstància es produirà si hi ha algun error o es troba al final de l'arxiu.
11

5.2.3 Lectura i escriptura de dades formatades. Les funcions fprintf() i
fscanf()
Les funcions fprintf() i fscanf() es comporten igual que les funcions printf() i scanf() excepte pel
fet que necessiten un argument addicional per apuntar a l'arxiu corresponent. El format general és:
int fprintf(punter_arxiu,"cadena de control",llista d'arguments);
int fscanf (punter_arxiu,"cadena de control",llista d'arguments);
La funció fprintf() retorna el nombre de caràcters enviats a l'arxiu. Si es produeix un error retorna
un número negatiu.
La funció fscanf() retorna el nombre d'elements que ha pogut emparellar. Quan arriba al final de
l'arxiu retorna la constant EOF.
Aquestes funcions són especialment importants quan es vol llegir o escriure dades de diferents
tipus. El següent programa és un bon exemple d'això:
12

Creeu un nou arxiu del tipus C anomenat m5p03.c i escriviu el següent codi:
// m5p03.c - Lectura i escriptura amb fprintf() i fscanf() -
#include
int main(){
FILE *f;
int codi;
char nom[20];
char cognom[20];
float nota;
f = fopen ("prova.txt","w");
printf("\n Introdueix les dades.");
printf("\n posa 0 al codi per finalitzar\n");
if (f!=NULL){
do{
printf("\nIntroduiu el codi...");
scanf(" %d",&codi);
if(codi!=0){
printf("Introduiu el nom... ");
scanf(" %s",nom);
printf("Introduiu el cognom...");
scanf(" %s", cognom);
printf("Introduiu la nota...");
scanf(" %f",&nota);
fprintf(f, "%d %s %s %f\n",codi, nom, cognom, nota);
}
}while (codi!=0);
fclose(f);
}
/* lectura */
printf("\n\n************** lectura ************* \n\n");
if ( (f = fopen ("prova.txt","r"))!=NULL){
while (fscanf(f, "%d %s %s %f",&codi, nom,cognom, &nota) != EOF)
printf("%d %s %s %.2f\n",codi, nom, cognom, nota);
fclose(f);
}
system("pause");
}
13

Explicació del programa
Es pot comprovar que el funcionament de fprintf() és similar a printf(). Amb una funció scanf() es
llegeix el valor de les variables codi, nom, cognom i nota i després s'escriu el contingut d'aquestes
quatre variables a l'arxiu apuntat per f de la mateixa forma que es faria a la pantalla:
fprintf(f, "%d %s %s %f\n",codi, nom, cognom, nota);
El procés d'escriure és exactament igual:
while (fscanf(f, "%d %s %s %f",&codi, nom,cognom, &nota) != EOF)
printf("%d %s %s %f\n",codi, nom, cognom, nota);
Mentre que la funció fscanf() no trobi el final de l'arxiu, es va llegint la informació en grups de
quatre dades. Després s'escriu per pantalla el contingut de les variables.
14

5.2.4 L’accés directe
En aquest punt parlarem del que es coneix com accés directe. L’accés directe consisteix en indicar
la posició a la que volem accedir. Aquesta posició s’indica en bytes. Les principals funcions per a
l’accés directe són: fseek i ftell.
fseek
Aquesta funció ens ajudarà a situar-nos en una posició donada dins el fitxer.
on:
int fseek(FILE *stream, long offset, int origen)
• stream és el punter al fitxer que estem utilitzant.
• offset és el nombre de bytes que ens anem a desplaçar.
• origen és el punt de partida del desplaçament. L’origen pot tenir tres valors, els quals es
mostren a la següent taula.
Si ha anat bé, la funció retorna 0. Altrament retorna diferent de 0.
A continuació anem a veure una altra funció que ens retorna la posició en la que ens trobem dins el
fitxer.
ftell
Aquesta funció retorna el punter actual del fitxer i l’utilitzarem per a obtenir la posició actual d’un
fitxer. El desplaçament es mesura en bytes i des de l’inici del fitxer. Normalment podem utilitzar el
valor que ens retorna l’ftell per cridar a la funció fseek.
long int ftell(FILE *stream)
La funció ftell retorna la posició en octets en la qual ens trobem dins el fitxer.
Podem utilitzar aquesta funció per a conèixer la longitud exacta del fitxer:
fseek(f,0,SEEK_END);
l=ftell(f)
15

Creeu un arxiu anomenat m5p04.c amb el següent contingut
//m5p04.c - Trobar la mida d'un arxiu -
#include
int mida(char *);
int main(int argc, char *argv[]){
printf("mida de %s:%d\n",argv[1],mida(argv[1]));
system ("pause");
}
int mida(char *arxiu){
FILE *f;
if ((f=fopen(arxiu,"rb"))==NULL){
printf("error, no s'ha pogut obrir l'arxiu\n");
return 0;
}
fseek(f, 0,SEEK_END);
return ftell(f);
}
Explicació del programa
La funció main() d'aquest programa rep un argument a través de la línia de comandament. No es fa
cap comprovació del nombre d'arguments per tal de facilitar la lectura del codi, no obstant, seria
interessant fer-la. Aquest argument serà el nom de l'arxiu, la mida del qual volem saber. La mida es
troba a partir de la funció mida(). Aquesta funció té com únic argument el nom de l'arxiu. Aquesta
funció s'encarrega d'obrir-lo. A continuació, amb:
fseek(f, 0,SEEK_END);
fa que el punter de posició de lectura de l'arxiu apunti a la darrera posició (0 posicions començant
per l'última). Aleshores, la funció ftell() torna la posició d'aquest punter començant pel principi, és a
dir, torna la mida de l'arxiu.
16

Exercicis
1. Treure els comentaris d’un arxiu font C/C++
Escriu un programa que llegeixi un arxiu C/C++ i creï un de nou amb l’extensió .txt on les línies
de comentari siguin eliminades.
2. Encriptació d'un correu
En Pere vol codificar els correus electrònics que envia als seus amics. Per aquest motiu va escriure
una programa C/C++ per codificar-los i un altre per descodificar-los. Un cop comprovat el seu
funcionament , va fer arribar a la resta d’amics el programa executable per poder llegir els
missatges que ell els envia .
En Pere fa arribar els missatges a traves d’un fitxer anomenat correu.txt i el seu contingut és un
seguit de zeros ( 0 ) i uns ( 1 ). Per llegir el correu, cal agrupar-los de 8 en 8 i transformar aquest
nombre binari en un nombre decimal. El seu corresponent codi ASCII és el caràcter que ens envia.
El conjunt de caràcters a utilitzar corresponen als de la taula ASCII ( del 0 al 127 ).
Exemple de les tres primeres lletres que trobaràs en el fitxer correu.txt :
caràcter Binari decimal
E 01000101 69
l 01101100 108
n 01101110 110
Es demana que escriguis un programa C/C++ que et permeti llegir els correus que s’envien
codificats amb aquest mètode i mostri el missatge en el monitor..
A l'arxiu correu.txt tens un missatge de prova. Si el teu programa funciona correctament hauràs de
llegir en la pantalla la següent dita:
El negoci d'en Robert amb les cabres, que en donava dues negres per una de blanca.
17

Nota: Per a treballar millor feu servir un codi semblant a aquest
int main(){
char c[]="01000101",*finalPtr;
int a =strtol(c,&finalPtr,2);
printf("%c",a);
system("pause");
}
La funció strtol ens transformarà la cadena del primer paràmetre en un número interpretant-lo en la
base que li diem en el tercer paràmetre (en aquest cas 2). No us preocupeu gaire d’entendre el segon
paràmetre poseu-lo tal qual i ja està.
Si voleu més informació mireu http://c.conclase.net/librerias/funcion.php?fun=strtol
3. Ordenació
Tenim dos fitxers A.txt i B.txt. Cada un d’ells conté un número indeterminat de nombres enters de
forma ordenada. Escriviu un programa que escrigui a un fitxer C.txt tots els enters que hi ha en els
dos fitxers de forma ordenada. Si algun valor surt repetit només cal ficar-ho una vegada
18

Pràctica
Generalitat de Catalunya
Departament d’Educació
IES SEP Mare de Déu de la Mercè
CICLE: DESENVOLUPAMENT
D’APLICACIONS INFORMÀTIQUES
CRÈDIT: C5
PROGRAMACIÓ ESTRUCTURADA I MODULAR
CURS:
1r
DATA:
05-05-10
Nom i Cognoms: Nota:
Degut a les dificultats de la policia per identificar els criminals, fa temps es va decidir substituir
els dibuixants tradicionals per un programa informàtic que crea un retrat robot a partir d’una
descripció del delinqüent. Actualment es disposa de milers de fitxers de text que contenen
aquestes descripcions. Un individu es descriu amb 5 línies de text corresponents a les 5 línies
del retrat robot. A cada línia s’apunta el nombre de vegades que apareix cada caràcter seguit del
caràcter en qüestió, tal i com es pot veure en el següent exemple:
Es demana fer un programa que a partir de la descripció d’un criminal que llegirem d’un fitxer
de text, mostri el retrat robot per pantalla.
19

5.3 Fitxers binaris
La llibreria estàndard d'entrades i sortides de C proporciona dues funcions que permeten llegir i
escriure blocs sencers de dades. Aquestes funcions són fread() i fwrite() i tenen els següents
protocols:
size_t fread (void *buffer, size_t mida, size_t numelements, FILE *arxiu);
size_t fwrite (void * buffer, size_t mida, size_t numelements, FILE * arxiu);
Aquestes funcions són especialment interessants per emmagatzemar o recuperar estructures
senceres i no camp per camp.
La funció fread llegeix numelements ítems de mida bytes del fitxer arxiu i els emmagatzema al
buffer. El punter associat al fitxer s’incrementa amb el nombre de bytes llegits. fread retorna el
nombre d’ítems llegits. Aquest nombre pot ser menor del que s’ha especificat a la seva crida si s’ha
arribat a la fi del fitxer o ha donat un error.
La funció fwrite escriu numelements ítems al fitxer arxiu, de mida bytes cadascun. Aquests ítems
estan al buffer. El punter associat al fitxer s’incrementa amb el nombre de bytes escrits. fwrite
retorna el nombre d’ítems escrits. Aquest nombre pot ser menor del que s’ha especificat a la seva
crida si s’ha arribat a la fi del fitxer o ha donat un error.
Presentarem dos programes, el primer dels quals permetrà emmagatzemar en un arxiu de disc
registres d'una base de dades d'alumnes i notes. L'accés a l'arxiu es farà de registre en registre i no
de camp en camp. Els valors dels diferents camps s'introduiran per teclat. Per finalitzar, l'entrada de
dades s'haurà d'introduir el valor -1 en el camp codi.
El segon dels programes permetrà llegir registres d'un arxiu i els mostrarà per pantalla. De la
mateixa forma que el primer programa, l'accés a l'arxiu es farà de registre en registre.
20

Creeu un nou arxiu anomenat m5p05.cpp i escriviu el següent codi:
//m5p05.cpp - Escriptura de registres en disc -
#include
#include
typedef struct fitxa{
int codi;
char nom[20];
char cognom[20];
float nota;
};
int main(){
FILE *fp;
fitxa alumne;
char arxiu[12];
printf("Introduiu el nom de l'arxiu de dades\n");
scanf("%s",arxiu);
if((fp=fopen(arxiu, "wb"))==NULL)
printf("Error al intentar obrir l'arxiu\n");
else
do {
printf("\nIntroduiu el codi...");
scanf(" %d",&alumne.codi);
if(alumne.codi!=-1) {
printf("\nIntroduiu el nom... ");
scanf(" %s",alumne.nom);
printf("\nIntroduiu el cognom...");
scanf(" %s", alumne.cognom);
printf("\nIntroduiu la nota...");
scanf(" %f",&alumne.nota);
fwrite(&alumne,sizeof(alumne),1,fp);
}
}while (alumne.codi!=-1);
fclose(fp);
}
21

Explicació del programa
Els registres que emmagatzemarem seran estructures del tipus fitxa definida com a estructura
global. Es defineix una variable d'aquesta estructura anomenada alumne. Aquesta variable ens
servirà de buffer per escriure tot el registre de cop a l'arxiu.
Per tal de finalitzar l'entrada de dades s'ha posat una comprovació darrere de l'entrada del camp
codi. Si el valor introduït és igual a -1, se surt del bucle, es tanca l'arxiu i acaba el programa.
Una vegada introduïts els quatre camps del registre s'emmagatzema de cop a l'arxiu amb la funció
fwrite():
fwrite(&alumne,sizeof(alumne),1,fp);
Aquesta línia es pot llegir com: escriu a l'arxiu apuntat per la variable fp, 1 bloc de 48 octets
(sizeof(alumne)=48) començant per l'adreça de memòria apuntada pel punter alumne.
El següent programa mostra com es pot llegir els registres sencers de l'arxiu creat amb el programa
anterior.
Creeu un nou arxiu anomenat m5p06.cpp i escriviu el següent codi:
//m5p06.cpp - Lectura de registres en disc -
#include
#include
typedef struct fitxa{
int codi;
char nom[20];
char cognom[20];
float nota;
};
int main(){
FILE *fp;
fitxa alumne;
char arxiu[12];
printf("Introduiu el nom de l'arxiu de dades\n");
scanf("%s",arxiu);
if((fp=fopen(arxiu, "rb"))==NULL)
printf("Error al intentar obrir l'arxiu\n");
else{
while (fread(&alumne,sizeof(alumne),1,fp))
printf("%d %20s %20s %.2f\n",alumne.codi,alumne.nom,alumne.cognom,
alumne.nota);
fclose(fp);
}
system("pause");
}
22

Explicació del programa
Aquest programa és realment similar a l'anterior. La lectura de dades del disc es fa amb la funció
fread() de la següent forma:
fread(&alumne,sizeof(alumne),1,fp);
Aquest línia pot llegir-se com: llegeix a l'arxiu apuntat per fp 1 bloc de 48 octets i escriu aquests
octets a la memòria començant per l'adreça apuntada pel punter alumne.
La funció fread() retorna el nombre d'elements llegits. Aquest pot ser més petit que el tercer
argument ( int nombre_de_elements ) en cas d'error o bé si em arribat a final del arxiu.
En el nostre exemple si la funció fread() retorna un valor false ( zero ) ens indicarà que em arribat a
final del arxiu de dades.
Com pot passar en molts casos ens pot interessar carregar tot el fitxer en una taula. Això
naturalment es pot fer llegint registre a registre en un bucle però també ho podem fer en una sola
instrucció si sabem quants elements tenim. Per exemple i suposant que tenim la variable
fitxa alumne[100]; :
fseek(fp, 0, SEEK_END);
nombreRegistres = ftell(fp)/sizeof(fitxa); // Calculem quants registres tenim
rewind(fp); //Funció que rebobina per tornar a principi de fitxer
fread(&alumne,sizeof(fitxa),nombreRegistres,fp); //Carreguem directament tot el fitxer a la taula
23

Exercici
1. Volem dissenyar un programa que ens permeti la gestió d’una senzilla agenda, a la qual
figuren nom i número de telèfon de diferents persones.
El programa ha de realitzar les següents tasques:
a) Entrada de dades: nom i telèfon
b) Buscar el número de telèfon d’una persona determinada
c) Eliminar les dades d’una persona
d) Modificar el número de telèfon d’una persona determinada
e) Llistar totes les dades
Aquestes tasques no s’han de realitzar seqüencialment, sinó a voluntat de l’usuari, és a dir el
programa ha de presentar el conjunt de tasques que pot realitzar i l’usuari triarà una d’elles.
Finalitzada aquesta tasca, el conjunt d’opcions ha d’estar disponible novament.
Consideracions: La tàctica per eliminar un registre hauria de ser la següent es va llegint
del fitxer i es va gravant en un fitxer auxiliar; quan trobem el registre que volem eliminar
simplement no el gravem a l’altre fitxer. Al final cal eliminar el fitxer original i reanomenar
l’auxiliar amb el nom del fitxer original :
remove (“agenda.dat”);
rename (“auxiliar.dat”, “agenda.dat”);
A l’hora de modificar s’ha de considerar que després de llegir un registre, el fitxer ha mogut
el marcador fins el següent registre i per tant ens caldrà retrocedir una posició.
24

Pràctica
Generalitat de Catalunya
Departament d’Educació
IES SEP Mare de Déu de la Mercè
CICLE: DESENVOLUPAMENT
D’APLICACIONS INFORMÀTIQUES
CRÈDIT: C5
PROGRAMACIÓ ESTRUCTURADA I MODULAR
CURS:
1r
DATA:
07-06-10
Nom i Cognoms: Nota:
Volem gestionar una petita base de dades a la qual tenim: categories i els productes d’aquestes
categories. La informació que guardem és la següent:
Categories - Cod_cat : autonumèric
- Nom_cat: string
Productes - Cod_prod : autonumèric
- Nom_prod: string
- Cod_cat : clau forana
Els dos fitxers han d’estar sempre ordenats pel codi i no ha d’haver-hi cap salt de codi ( és a dir si hi
ha n registres, els codis aniran de 1 a n).
El programa ha de permetre les següents opcions:
1. Introduir una nova categoria: Se’ns dóna un nom, si no existeix se li assigna el valor de
l’últim codi +1 i es grava.
2. Eliminar una categoria: se’ns dóna un nom i l’esborrem. Tots els codis de les categories
posteriors han de ser reassignats i per tant també els codis de categoria dels seus productes.
Tots els productes de la categoria eliminada han de ser també eliminats i per tant també cal
la reassignació de codis.
3. Consulta per categoria: se’ns dóna un nom de categoria i llistem tots els seus productes.
4. Llistat de categories.
5. Introduir un nou producte: se’ns dóna un nom i un codi de categoria. Si la categoria existeix
i el producte no, se li assigna el codi pertinent i es grava.
6. Eliminar un producte: se’ns dóna un nom i l’esborrem. Cal fer la reassignació de codis.
7. Llistat de productes amb la seva categoria.
A l’hora d’entregar la pràctica cal que els fitxers tinguin prou dades per poder provar el
funcionament en condicions. Està totalment prohibit l’ús de taules per emmagatzemar les dades
dels fitxers i a més :
- Cal fer un bon disseny descendent.
- Cal declarar les mínimes variables globals.
- Les tuples cal declarar-les amb typedef.
- Cal comentar el codi
25