IMPORTANT: Per accedir als fitxer de subversion: http://acacha.org/svn (sense password). Poc a poc s'aniran migrant els enllaços. Encara però funciona el subversion de la farga però no se sap fins quan... (usuari: prova i la paraula de pas 123456)

Crides de sistema

Consulteu l'apartat Gestió d'entrades i sortides de fitxers de l'article Crides al sistema Unix.

Exemples

Creació d'un fitxer PID

#define PID_FILE "/var/run/echod.pid"

int pid_file;
char str[30];  

pid_file=open(PID_FILE,O_RDWR|O_CREAT,0640);
sprintf(str,"%d\n",getpid());
write(pid_file,str,strlen(str)); 

Consulteu l'apartat guia de bones pràctiques de l'article programació de dimonis.

Funcions de la llibreria estàndard de C (stdio)

Podeu consultar una llista de les funcions consultant el manual:

$ man stdio

Recursos:

Fitxers d'entrada i sortida estàndard

 FILE *stdin;
 FILE *stdout;
 FILE *stderr;

FILE és una redefinició (typedef) d'un punter a un fitxer. S'utilitza per identificar un fitxers i és quelcom similar a la idea de descriptor de fitxer (enter) de les crides de sistema.

Obertura de fitxers. fopen

#include <stdio.h>
FILE *fopen(const char *path, const char *mode);
FILE *fdopen(int fildes, const char *mode);
FILE *freopen(const char *path, const char *mode, FILE *stream);

La funció fopen én sistemes Unix és realment una funció de més alt nivell que la crida al sistema open().

Aquesta funció ens permet obrir un fitxer per començar a operar amb el fitxer. El valor de retorn és un punter al fitxer que utilitzarem en funcions de manipulació de fitxers.

El valor retornat es pot considerar un flux de dades amb el que podem treballar. Les operacions que podrem realitzar depenen del mode en que haguim obert el fitxer:

Mode descripció comença...
r rb obre per a lectura al principi del fitxer
w wb obre per a escriptura (crea el fitxer si no existeix i sobreescriu si el fitxer ja existeix). al principi del fitxer
a ab obre el fitxer per escriure al final (append) final
r+ rb+ r+b obre per llegir i escriure principi
w+ wb+ w+b obre per llegir i escriure. Sobreescriu continguts principi
a+ ab+ a+b obre el fitxer per escriure i llegir al final (append) final

El fitxer pot ser de dos tipus: text o binari. La b indica binari.

Cal tenir en compte que els fitxers de text no són igual en Unix que en Windows.

Recursos:

Tancament de fitxers. fclose

Allibera el punter a un fitxer. S'utilitza per tancar el fitxer un cop hem acabat d'operar-hi.

#include <stdio.h>

int fclose(FILE *fp);

Recursos:

fwrite

Permet escriure en un fitxer (que hem obert previament).

#include <stdio.h>

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

size_t fwrite(const void *ptr, size_t size, size_t nmemb,FILE *stream);

Recursos:

Exemple

#include <stdio.h>
#include <string.h>  

int main(void)
{
    FILE *file_ptr;
    int iCount;
    char arr[6] = "hello";  

    file_ptr = fopen("sample.txt", "wb");
    iCount = fwrite(arr, 1, strlen(arr), file_ptr);
    fclose(file_ptr);

    return 0;
}


Accés aleatori. Funcions fseek, fsetpos, ftell, fgetpos

Les comandes fseek i fsetpos permeten col·locar el punter d'un fitxer en un punt concret del fitxer:

#include <stdio.h>

int fseek(FILE *stream, long offset, int whence);
int fsetpos(FILE *stream, fpos_t *pos);

I les funcions ftell i fgetpos permeten saber on esta el punter del fitxer:

long ftell(FILE *stream);
int fgetpos(FILE *stream, fpos_t *pos);

La funció rewind permet tornar a col·locar el punter al principi del fitxer. Cal recordar que a l'hora d'obrir un fitxer es pot obrir al principi o al final (per exemple per a operacions append)

Recursos:

Funcions de manipulació de fitxers. getx, putx, fgetx, fputx, fscanf, fprintf...

Hi han infinitat de funcions per manipular fitxers (per caràcter, per cadena de caràcters, binaris, seqüencials o aleatòris, etc...)

Totes aquestes funciones requereixen

Consulteu el manual:

 $ man stdio

Recursos:

Recursos:

Exemples

Lectura de bytes en un fitxers binari

#include <stdio.h>

int main(void) 
{
   char buffer[5] = {0};  /* initialized to zeros */
   int i;
   FILE *fp = fopen("myfile.dat", "rb");
   if (fp == NULL) {
       printf("The file didn't open.\n");
       return 0;
   }
   for (i=0; i < 5; ++i) {
       int rc = fgetc(fp);
       if (rc == EOF) {
           printf("There was an error reading the file.\n");
           break;
       }
       buffer[i] = rc;
   }
   fclose(fp);
   if (i == 5) {
       printf("The bytes read were...\n");
       putchar(buffer[0]);
       putchar(buffer[1]);
       putchar(buffer[2]);
       putchar(buffer[3]);
       putchar(buffer[4]);
       putc('\n', stdout);
   }
   return 0;
}

Un altre exemple de lectura de fitxer binari

// ex1.c : Defines the entry point for the console application.
// 

#include <stdio.h>
#include <string.h>
#include <windows.h> 

int FileSuccess(FILE * handle,const char * reason, const char * path) {
 	OutputDebugString( reason );
 	OutputDebugString( path );
	OutputDebugString(" Result : ");
	if (handle==0)
	{
		OutputDebugString("Failed");	
		return 0;
	}
	else
	{
		OutputDebugString("Suceeded");
		return 1;
	}
}   

int main(int argc, char * argv[])  

{
	const char * filename="test.txt";
	const char * mytext="Once upon a time there were three bears.";
	int byteswritten=0;
	FILE * ft= fopen(filename, "wb");
	if (FileSuccess(ft,"Opening File: ", filename)) {
		fwrite(mytext,sizeof(char),strlen(mytext), ft);
		fclose( ft );
	} 
	printf("len of mytext = %i ",strlen(mytext));
	return 0;
}

Fitxer seqüencial indexat

// ex2.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h> 

struct indextype {
	fpos_t pos;
	int size;
};  

void CreateFiles() {
	const char * indexfilename="index.dat";
	const char * datafilename="data.dat";
	const char * msg = "This is string %d followed by %d asterisks :";
    char * text;
	
	int i=0;
	int j= 0;
 	struct indextype index;   

	FILE * ftindex= fopen(indexfilename, "wb");
	FILE * ftdata = fopen(datafilename, "wb");   

text=(char * ) malloc( 1100); for (i=0;i < 1000; i++ ) { sprintf(text,msg,i,i+5); for ( j=0; j<i+5; j++) strcat(text,"*"); index.size = (int)strlen(text); fgetpos(ftdata, &index.pos ); fwrite(&index,sizeof(index),1, ftindex); fwrite(text,sizeof(char),strlen(text), ftdata); }

    fclose(ftindex);
	fclose(ftdata);
    free(text);
} 

void ShowRecord(int recnum ) {

const char * indexfilename="index.dat"; const char * datafilename="data.dat";

      char * text;

int i=0; int j= 0; struct indextype index;

FILE * ftindex= fopen( indexfilename, "rb"); FILE * ftdata = fopen( datafilename, "rb"); text=(char * ) malloc( 1100);

fseek( ftindex, sizeof(index)*(recnum) ,SEEK_SET ); fread( &index,1,sizeof(index),ftindex);

fsetpos( ftdata, &index.pos );

   fread( text,index.size, 1, ftdata);

text[ index.size ]='\0';

   fclose( ftindex );

fclose( ftdata );

printf("Record %d is %s",recnum,text );

   free(text);
}

int main(int argc, char * argv[])
 { 
	CreateFiles();

ShowRecord(675);

}