¡Descarga Apunts Fitxers y más Exámenes selectividad en PDF de Informática solo en Docsity!
Fitxers
fitxer Els fitxers són seqüències de bytes de tamany variable emmagatzemades en el disc. El sistema operatiu s’encarrega de que poguem obrir fitxers donant nom i llegir-ne el contingut. Hi ha dos tipus de fitxer:
- binari, a on les dades poden ser de qualsevol tipus. La interpretació sobre les dades l’ha de fer el programa.
- de text, a on cada byte del fitxer s’interpreta com un caràcter (aquests són els fitxers que estudiarem).
mode d’apertura Els dos modes amb què es pot obrir un fitxer són:
- mode lectura, si la intenció del programa és simplement llegir les dades del fitxer; i
- mode escriptura, si la intenció del programa només es escriure dades en el fitxer. Existeixen modes de lectura/escriptura però no els estudiarem.
Programes que fan servir fitxers
Els fitxers es fan servir desde un programa com seqüències d’entrada o de sortida. Si el fitxer s’obre en mode lectura, el que farem és anar llegint les dades tal com estan escrites en el fitxer fins al final. La manera és semblant a com es fa servir cin. Si el fitxer s’obre en mode escriptura, anirem escrivint les dades del fitxer en l’ordre en que aniràn escrites, d’una forma semblant a com fem servir el cout.
Una idea important és que un programa ha de tancar els fitxers que obre, ja que tancant un fitxer permetem al sistema operatiu que deixi a un altre programa obrir-lo. Els fitxers són un recurs compartit dels diferents programes que s’executen i s’han d’utilitzar de la forma més responsable possible.
Per fer servir fitxers és necessari fer el següent include:
#include
Quan executem un programa, aquest s’executa en un directori concret del sistema. Si llegim fitxers, aquests s’han de trobat en el mateix directori que el programa, i si escrivim fitxers, aquests es crearan en el mateix directori.
Obrir un fitxer en mode lectura
En C++, per obrir un fitxer en mode lectura s’ha de crear una variable d’un tipus especial (el tipus ifstream). El tipus ifstream té una i per indicar input. En la declaració de la variable s’ha de fer servir una sintaxi especial per indicar el nom del fitxer:
ifstream fin("dades.txt");
Aquesta declaració crea una variable fin de tipus ifstream que ens permet llegir del fitxer “dades.txt” en mode lectura.
Tancar un fitxer
Els fitxers en C++ es tanquen automàticament quan la variable associada desapareix. Per entendre quan les variables desa- pareixen ens cal entendre l’abast d’una variable.
Abast de les variables
En general una variable declarada en un bloc desapareix quan el bloc acaba, és a dir:
{ int x; x = 5; cout << x; } // x desapareix aqu´ı x = 3; // error: x no existeix
El bloc d’instruccions que conté la variable i que la pot accedir determina el seu abast: desde quan i fins quan està accessible. Típicament, les accions o funcions o el while i el for fan servir blocs i per tant les variables que creem a dins d’aquests blocs no són visibles a fora del bloc. Per exemple:
void func_X(int N) { int s = 0; for (int k = 0; k < 20; k++) { int x = 4; s = s + k * x; } x = 5; // error, x ja no existeix k = 1; // error, k tampoc existeix return s; }
Es poden crear blocs especialment per contenir variables que no volem fer servir enlloc més que en una part del codi:
int main() { double x1, y1, y2, y2; cin >> x1 >> y1 >> x2 >> y2;
{ double dx, dy; dx = x2 - x1; dy = y2 - y1; cout << sqrt(dxdx + dydy) << endl; }
dx = 1.0; // error, dx ja no existeix // ... }
En aquest programa, les variables dx i dy només es fan servir en el bloc que les contenen (i aquest bloc està enmig del programa sense formar part de cap while o for o if).
Exercici 1 Indica quines de les instruccions del següent codi donarien error:
int main() { int x, y;
{ int a = 1; x = 3; }
a = 2;
{ int b = 4; y = 7; a = 2; }
x = 4; b = 2; }
int n, suma = 0; f >> n; while (!f.eof()) { suma += n; f >> n; } cout << "La suma ´es: " << suma << endl; }
És important veure que per acabar el bucle principal, s’ha fet servir eof(), cosa que ens evita haver de tractar amb un sentinella (i de fet ens permet definir una seqüència d’enters ja siguin positius o negatius sense sentinella). Fer servir fitxers, per tant, implica:
- fer “#include ”;
- crear una variable tipus ifstream i posar el nom del fitxer que volem llegir;
- fer servir eof() per detectar el final del fitxer;
- fer servir la variable com si fós cin quan volem llegir dades del fitxer.
Exercici 2 Fes un programa que llegeixi un fitxer anomenat reals.txt amb una seqüència de nombres reals i calculi la seva mitjana.
Escriptura de fitxers
El cas de l’escriptura és anàleg al de la lectura amb dues modificacions:
- la declaració de variables tipus fitxer en mode escriptura és lleugerament diferent;
- l’escriptura es fa tal com amb cout.
Obrir un fitxer en mode escriptura
Per obrir un fitxer en mode escriptura farem:
ofstream fout("fibo.txt");
La declaració s’assembla molt a la de lectura, simplement el tipus és ofstream (amb una o de output). El nom del fitxer proporcionat serà el que es crearà (si ja existeix se sobreescriurà).
Escriure dades en un fitxer
Per escriure dades, es fa servir la variable tal com el cout, tal i com mostrem una dada per pantalla:
int a = 5; fout << "El valor de ’a’ ´es " << a << endl;
Aquesta instrucció no mostraria res per pantalla però afegiria el text “El valor de ’a’ ´es 5” al final del fitxer (inclòs el salt de línia). Com abans, s’ha fet servir el nom fout per establir una analogia amb cout, però aquest nom, tal com el nom de les variables, el podem escollir lliurement.
Exemple de escriptura de fitxers
El següent programa crea un fitxer amb els 40 primers números de la seqüència de Fibonacci (a on cada nombre és la suma dels anteriors):
#include #include using namespace std;
int main() { int a = 1, b = 1, k; ofstream fout("fibo.txt");
fout << a << endl << b << endl; k = 3; while (k <= 40) { int aux = a + b; a = b; b = aux; fout << b << endl; k++; } }
Exercici 3
Fes un programa que emmagatzemi en un fitxer (en una columna) una llista dels números primers menors que 1000000000.
Generated on: 2008-11-30 21:47 UTC.
