MIS. Lizbeth Alejandra Hernández González

Función en Pascal Descripción

VariableArch:Text

VariableArch:File of Integer

Assign(VariableArch,Nombre)

FileMode=valor;

Reset(VariableArch);

Append(VariableArch);

Rewrite(VariableArch);

Seek(VariableArch,Num);

Filesize(VariableArch);

Flush(VariableArch);

Close(VariableArch);

Write(VariableArch,Variable);

Read(VariableArch,Variable);

EOF(VariableArch);

EOLN(VariableArch);

{$I+-}

ioresult = 0

Declara una variable de archivo de texto

Declara una variable de archivo tipificado (binario)

Asigna un apuntador a un archivo llamado nombre

Establece el modo de acceso (0:R, 1:W, 2:R/W)

Abre un archivo

Abre un archivo de texto existente para agregar (si el archivo está cerrado lo cierra y vuelve a abrir, se

posiciona al final del archivo).

Crea y prepara un archivo para escritura

Se posiciona en el registro con posición Num

Número de datos en el archivo empezando en cero

Forza al buffer a escribir al archivo

Cierra un archivo

Escribe al archivo

Lee de el archivo y deja información en variable

Fin de archivo

Fin de línea

Activa o Desactiva verificación de entrada/Salida

Si el archivo existe ioresult = 0

Funciones de archivos en C

En C se utilizan las funciones de entrada y salida tradicionales (a pantalla) anteponiéndoles una “f” para referirse a archivos.

<stdio.h>

clearerr fclose feof ferror fflush fgetc fgetpos

fgets fopen formato fprintf fputc fputs fread

freopen fscanf fseek fsetpos ftell fwrite getc

getchar gets perror printf putc putchar puts

remove rename rewind scanf setbuf setybuf sprintf

sscanf tmpfile tmpnam ungetc vfprintf vprintf vsprintf

Pasos Declarar el apuntador de archivo

FILE *f1;

Abrir el archivo indicando tipo de apertura f1=fopen(“archivo.txt”, “r+”)

Manipular el archivo Leer

fgetc fgets fscanf fread*

Escribir

fputc fputs fprintf fwrite*

*para archivos binarios

Funciones para el manejo de archivos FILE* fopen (const char*, const char*); Abrir un archivo

int fclose (FILE*) Cerrar un archivo

int remove (const char*); Borrar un archivo

int rename (const char*, const char*); Renombrar un archivo

int fprintf (FILE*, const char*, ...); Escribir texto con formato en un archivo

int fscanf (FILE*, const char*, ...); Leer texto con formato en un archivo

Int fgetc (FILE*); Leer un caracter

char* fgets (char*, int, FILE*); Leer una cadena

int fputc (int, FILE*); Escribir un character

int fputs (const char*, FILE*); Escribir una cadena

size_t fread (void*, size_t, size_t, FILE*); Leer una estructura de un archivo binario

size_t fwrite (const void*, size_t, size_t, FILE*); Escribir una estructura a un archivo binario

/*

* File Positioning Functions

*/

int fseek (FILE*, long, int); Posicionarse en determinado registro

void rewind (FILE*); Rebobinar (posicionar el apuntador al inicio del archivo)

int feof (FILE*); Función que determina si el apuntador se encuentra al final del archivo.

<stdio.h>

Tipos de acceso a los archivos Tipo

Acceso Descripción

"r" Abre un archivo para lectura. El archivo debe de existir

"w" Abre para escritura. Si el archivo no existe se crea, pero si existe se sobreescribe.

"a" Abre para escribir al final. Si el archivo no existe se crea.

"r+" Abre para Escritura/Lectura. El archivo debe existir.

"w+" Abre para Escritura/Lectura. Si el archivo no existe se crea, pero si existe se sobreescribe.

"a+" Abre para escribir al final de él y leer. Si el archivo no existe se crea.

"rb" Abre un archivo binario para lectura. El archivo debe existir.

"wb" Abre un archivo binario para escritura. Si el archivo no existe se crea, pero si existe se sobreescribe.

"ab" Se abre un archivo binario para escribir al final de el. Si el archivo no existe se crea.

"rb+" Abre un archivo binario para lectura/Escritura. El archivo debe existir

"wb+" Abre un archivo binario para lectura/escritura. Si el archivo no existe se crea, pero si existe se sobreescribe.

"ab+" Abre un archivo binario para lectura y añadir. Si el archivo no existe se crea.

Programa que lee un archivo en pascal y lo despliega en pantalla

1. PROGRAM leeFile; 2. uses crt; 3. var origen:TEXT; DECLARACIÓN 4. caracter:char; 5. begin 6. assign(origen,‘prueba.txt'); 7. {$I-}{directiva que pone en OFF la salida de errores} 8. reset(origen); {abro el archivo origen} 9. {$I+}{ponemos la directiva en ON nuevamente} 10. {si ioresult=0 el archivo existe, de lo contrario es un código de error} 11. if ioresult<>0 then 12. writeln('No existe el origen') 13. else 14. begin 15. while not eof(origen) do 16. begin 17. read(origen,Caracter);{leemos del archivo} 18. write(caracter); {desplegamos el caracter en pantalla} 19. end;{while not eof} 20. close(origen); 21. end; 22. ReadKey; {pedimos una tecla para terminar} 23. end.

El mismo archivo en C 1. #include <stdio.h>

2. #include <stdlib.h>

3. #include <strings.h>

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

5. {

6. FILE *f1;

7. char linea[250];

8.

9. if ((f1=fopen("prueba.txt","r+")) != NULL){

10. while (!feof(f1)){

11. fgets(linea,250,f1);

12. printf(strcat(linea,"\n"));

13. }

14. fclose(f1);

15. }

16. system("PAUSE");

17. return 0; }

Manejo de cadenas en C Las cadenas están definidas como un arreglo de

caracteres o un apuntador a una porción de memoria conteniendo caracteres ASCII. Una cadena en C es una secuencia de cero o más caracteres seguidas por un caracter NULL o “\0”:

Representación de un arreglo.

Es importante preservar el caracter de terminación NULL, ya que con éste es como C define y maneja las longitudes de las cadenas.

Todas las funciones de la biblioteca estándar de C lo requieren para una operación satisfactoria.

Se deberán usar las funciones para manejo de cadenas y no tratar de manipular las cadenas en forma manual desmantelando y ensamblando cadenas.

Funciones para el manejo de cadenas <strings.h> char *strcpy(const char *dest, const char *orig) -- Copia la

cadena de caracteres apuntada por orig (incluyendo el carácter terminador '\0') al vector apuntado por dest.

int strcmp(const char *s1, const char *s2) – Compara s1 con s2. Devuelve número:

<0 (s1<s2)

=0 (s1=s2)

>0 (s1>s2)

int strlen(const char *s) -- Calcula la longitud de la cadena de caracteres.

char strcat(cadena1, cadena2) – concatena dos cadenas

char *strncat(char *s1, const char *s2, size_t n) -- Agrega n caracteres de s2 a s1.

int strncmp(const char *s1, char *s2, size_t n) -- Compara los primeros n caracteres de dos cadenas.

char *strncpy(const char *s1, const char *s2, size_t n) -- Copia los primeros n caracteres de s2 a s1.

strcasecmp(const char *s1, const char *s2) -- versión de strcmp() que ignora si son mayúsculas o minúsculas.

strncasecmp(const char *s1, const char *s2, size_t n) -- versión insensible a mayúsculas o minúsculas de strncmp() que compara los primeros n caracteres de s1.

El uso de muchas funciones es directo, por ejemplo: char *s1 = "Hola"; char *s2; int longitud; longitud = strlen("Hola"); /* long = 4 */ (void) strcpy(s2,s1); //fuente - destino Observar que el caracter de terminación NULL podría ser violado

cuando se usan estas funciones: strncat(), strncmp() y strncpy() : char *s1 = "Hola"; char *s2 = 2; int longitud = 2; strncpy(s2, s1, longitud); /* s2 = "Ho" */ donde s2 no tiene el

terminador NULL. S2[2]=0; S2[2]=‘\0’;

Búsqueda en cadenas char *strtok(char *s1, const char *s2) -- Divide la cadena apuntada a s1 en

una secuencia de ``tokens'', cada uno de ellos esta delimitado por uno o más caracteres de la cadena apuntada por s2. strtok(cadena, “;”)

char *strchr(const char *s, int c) -- Devuelve un puntero a la primera ocurrencia del carácter c en la cadena de caracteres s.

char *strrchr(const char *s, int c) -- Encuentra la última ocurrencia del caracter c en la cadena.

char *strstr(const char *s1, const char *s2) -- Localiza la primera ocurrencia de la cadena s2 en la cadena s1.

char *strpbrk(const char *s1, const char *s2) -- Regresa un apuntador a la primera ocurrencia en la cadena s1 de cualquier carácter de la cadena s2, o un apuntador nulo si no hay un caracter de s2 que exista en s1.

size_t strspn(const char *s1, const char *s2) -- Calcula la longitud del segmento inicial de s1 que consta únicamente de caracteres en s2.

size_t strcspn(const char *s1, const char *s2) -- Regresa el número de caracteres al principio de s1 que no coinciden con s2.

strtok char s1[] = "Hola a todos";

char *t1;

for ( t1 = strtok(s1," "); t1 != NULL; t1 = strtok(NULL, " ") )

printf("%s\n",t1);

Se emplea un ciclo for en una forma no regular de conteo:

1. En la inicialización se llama a la función strtok() con la cadena s1.

2. Se termina cuando t1 es NULL.

3. Se están asignando tokens de s1 a t1 hasta la terminación llamando a strtok() con el primer argumento NULL.