<assert.

h> Contiene la macro assert (asercin), utilizada para detectar errores lgicos y
otros tipos de fallos en la depuracin de un programa.
< complex.h> Conjunto de funciones para manipular nmeros complejos (nuevo en C99).
< ctype.h> Contiene funciones para clasificar caracteres segn sus tipos o para convertir
entre maysculas y minsculas independientemente del conjunto de caracteres
(tpicamente ASCII o alguna de sus extensiones).
< errno.h> Para testar los cdigos de error devueltos por las funciones de biblioteca.
< fenv.h> Para controlar entornos en coma flotante (nuevo en C99).
< float.h> Contiene la definicin de constantes que especifican ciertas propiedades de la
biblioteca de coma flotante, como la diferencia mnima entre dos nmeros en coma
flotante (_EPSOLON), el nmero mximo de dgitos de precisin (_DIG), o el rango de
valores que se pueden representar (_MIN, _MAX).
< inttypes.h> Para operaciones de conversin con precisin entre tipos enteros (nuevo en
C99).
< iso646.h> Para utilizar los conjuntos de caracteres ISO 646 (nuevo en NA1).
< limits.h> Contiene la definicin de constantes que especifican ciertas propiedades de los
tipos enteros, como rango de valores que se pueden representar (_MIN, _MAX).
< locale.h> Para la funcin setlocale() y las constantes relacionadas. Se utiliza para
seleccionar el entorno local apropiado (configuracin regional).
< math.h> Contiene las funciones matemticas comunes.
< setjmp.h> Declara las macros setjmp y longjmp para proporcionar saltos de flujo de
control de programa no locales.
< signal.h> Para controlar algunas situaciones excepcionales como la divisin por cero.
< stdarg.h> posibilita el acceso a una cantidad variable de argumentos pasados a una
funcin.
< stdbool.h> Para el tipo booleano (nuevo en C99).
< stdint.h> Para definir varios tipos enteros (nuevo en C99).
< stddef.h> Para definir varios tipos de macros de utilidad.
< stdio.h> Proporciona el ncleo de las capacidades de entrada/salida del lenguaje C
(incluye la venerable funcin printf).
< stdlib.h> Para realizar ciertas operaciones como conversin de tipos, generacin de
nmeros pseudo-aleatorios, gestin de memoria dinmica, control de procesos, funciones
de entorno, de sealizacin (??), de ordenacin y bsqueda.
< string.h> Para manipulacin de cadenas de caracteres.
< tgmath.h> Contiene funcionalidades matemticas de tipo genrico (type-generic) (nuevo
en C99).
< time.h> Para tratamiento y conversin entre formatos de fecha y hora.
< wchar.h> Para manipular flujos de datos anchos y varias clases de cadenas de
caracteres anchos (2 o ms bytes por carcter), necesario para soportar caracteres de
diferentes idiomas (nuevo en NA1).
< wctype.h> Para clasificar caracteres anchos (nuevo en NA1).
 Funcin strcat ANSI C
char *strcat(char*s1, const char *s2);
Aade una copia de la cadena apuntada por s2 (incluyendo el carcter nulo) al final de la
cadena apuntada por s1. El carcter inicial de s2 sobrescribe el carcter nulo al final de
s1.
La funcin retorna el valor de s1. Si la copia hace que los objetos se superpongan,
entonces el comportamiento no est definido.
Ejemplo:
#include <stdio.h>
#include <string.h>

int main()
{
char s1[11] = "Hola ";
char s2[6] = "amigos";

printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );
strcat( s1, s2 );
printf( "s1=%s\n", s1 );

return 0;
}

Nmeros aleatorios
#include <stdlib.h>
#include <stdio.h>

int main()
{
int i;
for(i=0; i<5; i++)
{
printf("%d\n", rand());
}
return 0;
}

Para cambiar el comportamiento del generador de nmeros aleatorios, podemos cambiar la

variable sobre la que se basa para realizar los clculos. A esta se le llama seed o semilla.
Esta semilla puede modificarse con la funcin srand():

srand(valor de la semilla)

La escritura de una funcin rdtsc() podr facilitarte las cosas, la sintaxis siguiente funciona con
GCC en Linux y la puedes encontrar con dev C++ en Windows:
#include <stdlib.h>
#include <stdio.h>

int rdtsc()
{
__asm__ __volatile__("rdtsc");
}

int main()
{
int i;
for(i=0; i<5; i++)
{
srand(rdtsc());
printf("%d\n", rand());
}
return 0;
}

string.h

string.h es un archivo de la Biblioteca estndar del lenguaje de programacin C que

contiene la definicin de macros, constantes, funciones y tipos y algunas operaciones de
manipulacin de memoria.

Las funciones declaradas en string.h se han hecho muy populares, por lo que estn
garantizadas para cualquier plataforma que soporte C. Sin embargo, existen algunos
problemas de seguridad con estas funciones, como el desbordamiento de buffer (buffer
overflow), que hacen que algunos programadores prefieran opciones ms seguras frente
a la portabilidad que estas funciones ofrecen. Adems, las funciones para cadenas de
caracteres slo trabajan con conjuntos de caracteres ASCII o extensiones ASCII
compatibles.

ALTAS, BAJAS Y MODIFICACIONES

1. /*
2. * autor: online.enlared@gmail.com
3. */
4. /* DECLARACION DE LIBRERIAS QUE SE VAN A UTILIZAR */
5. #include <stdio.h>
6. #include <ctype.h>
7. #include <string.h>
8. #include <stdlib.h>
9. #define M 3
10. #define FLUSH while(getchar() != '\n')
11. /* ESTRUCTURA DE LOS DATOS QUE VOY A USAR */
12. struct modelo
13. {
14. char codigo[5], descripcion[30];
15. float precio;
16. int stock;
17. };
18.
19. /* DEFINICION DE PROTOTIPOS */
20. void Menu();
21. void ValidarCodigo(char[]);
22. void ValidarCadena(char[]);
23. void IngresoDatos(struct modelo []);
24. void BajaDatos(struct modelo []);
25. void MuestraDatos(struct modelo []);
26. void ModificaDatos(struct modelo []);
27.
28. /* ACA ESTA EL MAIN */
29. int main ()
30. {
31. /* DECLARACIOM DE VARIABLES */
32. int i, opc1=9;
33. struct modelo datos[M];
34. /* PUESTA EN CERO DEL VECTOR DE CODIGOS */
35. for(i=0;i<M;i++)
36. strcpy(datos[i].codigo, "0000");
37. /* MENU PRINCIPAL */
38. while (opc1!=5)
39. {
40. Menu();
41. /* LEE OPCION*/
42. scanf("%d", &opc1);
43. switch (opc1)
44. {
45. /* OPCION ALTA DE PRODUCTOS*/
46. case 1:
47. IngresoDatos(datos);
48. break;
49. /* OPCION QUE DA DE BAJA UN ARTICULO */
50. case 2:
51. BajaDatos(datos);
52. break;
53. /* OPCION MUESTRA EN PANTALLA */
54. case 3:
55. MuestraDatos(datos);
56. break;
57. /* OPCION DE MODIFICACION DE ARTICULOS */
58. case 4:
59. ModificaDatos(datos);
60. break;
61. case 5:
62. system("cls");
63. printf("Fin del programa\n");
64. system("pause>>null");
65. break;
66. default:
67. printf("Opcion incorrecta");
68. system("pause>>null");
69. break;
70. }
71. }
72. return 0;
73. }
74. /* DEFINICION DE LAS FUNCIONES*/
75. void Menu()
76. {
77. system("cls");
78. printf("Menu principal\n");
79. printf("--------------\n");
80. printf("1 - Alta\n");
81. printf("2 - Baja\n");
82. printf("3 - Muestra en pantalla\n");
83. printf("4 - Modificacion\n");
84. printf("5 - Salir\n");
85. printf("Elija opcion: ");
86. }
87.
88. void ValidarCadena(char cadena[])
89. {
90. char aux[2000];
91. FLUSH;
92. fgets(aux, 2000, stdin);
93. while (strlen(aux)<1 || strlen(aux)>30)
94. {
95. printf("\nReingrese descripcion, maximo 30: ");
96. scanf("%s", aux);
97. }
98. strcpy(cadena, aux);
99. return;
100. }
101.
102. void ValidarCodigo(char codigo[])
103. {
104. char aux [50];
105. // FLUSH;
106. scanf("%s", aux);
107. while (strlen(aux)!=4)
108. {
109. printf("Reingrese codigo (4 caracteres): ");
110. scanf("%s", aux);
111. }
112. strcpy(codigo, aux);
113. }
114.
115. void IngresoDatos(struct modelo datos[])
116. {
117. int i;
118. float tempfloat;
119. system("cls");
120. printf("ALTA DE ARTICULOS\n");
121. printf("-----------------\n");
122. /* BUSCA UN LUGAR VACIO PARA GUARDAR*/
123. for(i=0;i<M;i++)
124. {
125. if(strcmp(datos[i].codigo, "0000")==0)
126. {
127. /* INGRESA CODIGO */
128. printf("Ingrese codigo: ");
129. ValidarCodigo(datos[i].codigo);
130. /* INGRESA DESCRIPCION */
131. printf("Ingrese Descripcion: ");
132. ValidarCadena(datos[i].descripcion);
133. /* INGRESA PRECIO */
134. printf("Ingrese Precio: ");
135. scanf("%f", &tempfloat);
136. datos[i].precio=tempfloat;
137. /* INGRESA STOCK */
138. printf("Ingrese Stock: ");
139. scanf("%d", &datos[i].stock);
140. break;
141. }
142. }
143. /* SI RECORRE TODO EL VECTOR DICE SI NO QUEDA ESPACIO
O SI FUE GUARDADO*/
144. if(i==M)
145. printf("No queda memoria suficiente para seguir
guardar datos\n");
146. else
147. printf("\nEl dato fue guardado exitosamente");
148. printf("\nPresione ENTER para continuar...");
149. system("pause>>null");
150. return;
151. }
152.
153. void BajaDatos(struct modelo datos[])
154. {
155. int a;
156. char aux[30];
157. system("cls");
158. printf("BAJA DE ARTICULOS\n");
159. printf("-----------------\n");
160. /* INGRESA CODIGO */
161. printf("Ingrese codigo del articulo que quiere dar de
baja: ");
162. FLUSH;
163. gets(aux);
164.
165. /*VALIDA CODIGO A DAR DE BAJA A LA TERCERA VEZ VUELVE A
MENU PRINCIPAL*/
166. while (strlen(aux)!=4)
167. {
168. printf("Reingrese codigo que quiere dar de baja
(rango 4): ");
169. FLUSH;
170. gets(aux);
171. }
172. /* BUSCA EN EL VECTOR SI LO ENCUENTRA PONE CODIGO A
CERO*/
173. for(a=0;a<M;a++)
174. {
175. if(strcmp(aux, datos[a].codigo)==0)
176. {
177. strcpy(datos[a].codigo, "0000");
178. break;
179. }
180. }
181. /* COMPRUEBA SI RECCORIO TODO EL VECTOR NO LO ENCONTRO,
SINO YA ESTA BORRADO*/
182. if (a==M)
183. printf("\nCodigo de articulo no encontrado.");
184. else
185. printf("\nArticulo borrado exitosamente");
186.
187. printf("\nPresione ENTER para continuar...");
188. system("pause>>null");
189. }
190. void MuestraDatos(struct modelo datos[])
191. {
192. int i;
193. system("cls");
194. printf("LISTADO DE ARTICULOS\n");
195. printf("--------------------\n");
196. printf("Codigo Descripcion Precio
Stock\n");
197. printf("------ ---------------------------- ------ ---
--\n");
198. /* LISTA TODO EL VECTOR CON SUS DISTINTOS TIPOS DE DATOS
(EL -29 ES PARA QUE LOS CARACTERES SE PONGAN A LA IZQUIERDA)*/
199. for(i=0;i<M;i++)
200. {
201. if(strcmp(datos[i].codigo, "0000")!= 0)
202. {
203. printf("%6s %-29s %6.2f %6d\n", datos[i].codigo,
datos[i].descripcion, datos[i].precio, datos[i].stock);
204. }
205. }
206. printf("\nPresiones ENTER para continuar...");
207. system("pause>>null");
208. }
209.
210. void ModificaDatos(struct modelo datos[])
211. {
212. int a, modificar=9;
213. float tempfloat;
214. char aux[30];
215.
216. system("cls");
217. printf("MODIFICACION DE ARTICULOS\n");
218. printf("-------------------------\n");
219. /* INGRESAS EL CODIGO A MODIFICAR */
220. printf("Ingrese codigo de articulo: ");
221. FLUSH;
222. gets(aux);
223. /* VALIDA */
224. while (strlen(aux)!=4)
225. {
226. printf("Reingrese codigo (4 caracteres): ");
227. FLUSH;
228. gets(aux);
229. }
230. /* RECORRE TODO EL VECTOR EN SU BUSQUEDA */
231. for(a=0;a<M;a++)
232. {
233. if(strcmp(aux, datos[a].codigo)==0)
234. {
235. system("cls");
236. /* MUESRTA SUBMENU DE OPCIONES */
237. printf("MODIFICAR ARTICULO numero %s\n", aux);
238. printf("------------------------------\n");
239. printf("1 - Modificar descripcion (Actualmente:
%s)\n", datos[a].descripcion);
240. printf("2 - Modificar precio (Actualmente:
%.2f)\n", datos[a].precio);
241. printf("3 - Modificar Stock (Actualmente: %d)\n",
datos[a].stock);
242. printf("4 - Volver al menu principal\n");
243. printf("Elija opcion: ");
244. /* LEE LA OPCION SELECCIONADA */
245. scanf("%d", &modificar);
246. switch(modificar)
247. {
248. case 1:
249. system("cls");
250.
251. /* INGRESA NUEVA DESCRIPCION */
252. printf("Ingrese nueva descripcion: ");
253. FLUSH;
254. gets(aux);
255.
256. /* LA VALIDA */
257. while(strlen(aux)<1 || strlen(aux)>29)
258. {
259. printf("Reingrese nueva descripcion
(valor maximo 29 caracteres): ");
260. FLUSH;
261. gets(aux);
262. }
263. /* LE ASIGNA EL NUEVO VALOR */
264. strcpy(datos[a].descripcion, aux);
265. printf("%s a sido asignado
exitosamente.", datos[a].descripcion);
266. system("pause>>null");
267. break;
268.
269. case 2:
270. system("cls");
271.
272. /* LEE NUEVO PRECIO Y LO ASIGNA */
273. printf("Ingrese nueva precio: ");
274. scanf("%f", &tempfloat);
275. datos[a].precio=tempfloat;
276. printf("%s ahora vale %.2f.",
datos[a].descripcion, datos[a].precio);
277. system("pause>>null");
278. break;
279. case 3:
280. system("cls");
281.
282. /* LEE NUEVO PRECIO Y LO ASIGNA */
283. printf("Ingrese nueva cantidad de stock:
");
284. scanf("%d", &datos[a].stock);
285. printf("%s ahora tiene %d articulos en el
sistema.",datos[a].descripcion, datos[a].stock);
286. system("pause>>null");
287. break;
288. case 4:
289. system("cls");
290. break;
291. }
292. break;
293. }
294. }
295.
296. /* SI NO ENCONTRO EL CODIGO MUESTRA UNA LEYENDA */
297. if (a==M)
298. {
299. printf("\nCodigo de articulo no encontrado.");
300. }
301.
302. printf("\nPresione ENTER para continuar...");
 303. system("pause>>null");
304. }

Archivos de acceso directo o aleatorio

La funcin fwrite transfiere a un archivo un nmero especificado de bytes empezando en
una posicin especificada de memoria. Los datos se escriben al principio de la posicin en
el archivo indicada mediante el apuntador de posicin de un archivo. La funcin fread
transfiere un nmero especificado de bytes de la posicin en el archivo, especificado por
el apuntador de posicin de archivo, a un rea en memoria empezando a partir de una
direccin especificada. Por ejemplo, para escribir un entero, en vez de especificar:
fprintf(cuentaPtr, %d, numero);
para escribir el mismo nmero de tipo int, se puede especificar:
fwrite( &numero, sizeof(int), 1, cuentaPtr);
ms adelante ese dato puede ser ledo con la funcin fread.
El primer parmetro de fprintf es la direccin de la variable a escribir en disco, el segundo
el tamao de bytes del dato que se va a escribir (devuelto por la funcin sizeof), el tercer
parmetro es el nmero de datos que se van a escribir del tamao especificado (por lo
comn ser 1) y el ltimo es el apuntador al archivo que se abri para escritura o
modificacin.
Para tener datos de tamao fijo en los archivos y lo que formalmente sern registros del
archivo se crea una estructura, es decir, un nuevo tipo de dato definido por el usuario y
compuesto por uno o varios tipos de datos con sus nombres de campo respectivos.
La declaracin de un tipo struct se hace antes de la funcin main de la siguiente manera:
structnombreEstructura
{
tipo1 campo1;
tipo2 campo2;
tipo3 campo3;
};
Por ejemplo, para crear una estructura que permita almacenar los datos de un cliente
puede declararse de la siguiente manera:
structDatosCliente
{
int cuenta;
char apellido[15];
char nombre[10];
float saldo;
};
De este modo se crea una estructura de nombre DatosCliente con los campos descritos,
en el programa se podrn declarar variables de tipo DatosCliente y para acceder a cada
uno de los campos se utilizara la notacin registro.campo. La declaracin de una variable
de este tipo se har:
structDatosClientemicliente;
De esta manera la variable micliente tiene los cuatro campos definidos para el tipo de
estructura, y el nombre del cliente se accede con la siguiente lnea:
micliente.nombre
El uso de una estructura y de las funciones fread, fwrite y fseek ser bsicamente la
diferencia entre programar para utilizar un archivo secuencial y un archivo de acceso
directo.
MANEJO DE CADENAS
Las cadenas de caracteres (string) son arreglos que se componen de caracteres
alfanumricos. El final de una cadena se indica con un caracter especial, ste es un byte
compuesto por 8 ceros binarios, es decir
0x00.
void main() {
char cad[10];
}
El tamao de la cadena debe ser lo suficientemente grande para contener dicho caracter
inclusive. Una cadena declarada como cad[10], podr contener como mximo 9 caracteres,
el ltimo ser ocupado por
0x00.
El archivo de cabecera string.h string.h string.h proporciona una serie de funciones que
permiten el manejo de cadenas de caracteres. No existen operadores que permitan
comparar cadenas o copiar una cadena en otra, por lo que se debe hacer uso de las
funciones definidas en string.h string.h.

FUNCION DESCRIPCION
strcpy Copia cadena en otra cadena
strcmp Compara dos cadenas
strlen Determina el largo de una cadena
strncpy Copia n caracteres de una cadena a otra
La funcin strcpy es una contraccin de la operacin string c stropy. El uso de estas
funciones requiere de un buen manejo de punteros. Por otro lado, dado que la cadena se
define como tipo char, es importante hacer la diferencia por ejemplo entre 'A' y "A", el
primero es el caracter A que se codifica en un byte (0x41) y el segundo elemento es una
cadena que contiene un caracter A y ocupa dos bytes (0x41, 0x00), el carcter y el fin de
cadena. Dado que el final de la cadena contiene el carcter 0x00, si se quiere borrar la
cadena, se puede asignar al primer elemento de la cadena dicho carcter cad[0]=0x00.

Variantes del uso de cadenas

Debido a que el uso de punteros es fundamental es importante establecer su uso en el
manejo de cadenas. En las implementaciones de C la variable puntero se especifica
mediante el tipo *identificador luego se tiene y la asignacin de la direccin se hace
mediante el operador &. De esta forma se tiene
#include <string.h>
void main()
{
char cad[10], buf[10]; /* cadenas de caracteres */

char *p; /* puntero a char */

p=&cad[0]; /* Asigna la direccion del elemento 0 */
p=cad; /* Idem */
strcpy(cad,HOLA); /* son lo mismo */
strcpy(cad[0],HOLA);
strcpy(&cad[0],HOLA);
strcpy(p,HOLA); /* Idem debido a que el argumento de strcpy es un puntero */
strcpy(buf[0],p); /* */
}
void main()
{
char cad[10], buf[10]; /* cadenas de caracteres */
strcpy(cad,HOLA); /* inicializando cad */
strcpy(buf[0],cad[2]); /* copiando parte de cad en buf */
}
void main()
{
char cad[10]={HOLA}; /* Declarando e iniicalizando */
strcpy(buf,cad); /* copiando de cad en buf */
}

COMO HACER ESTRUCTUAS SE GUARDA EN ARCHIVOS

1.2. Estructuras (struct)

Supongamos que tenemos la siguiente estructura para cada registro de libro:

--------------------------------------------------

ISBN | TITULO | AUTOR |ANIO EDICION | EDITORIAL

--------------------------------------------------

Lo primero es determinar el tipo de dato de cada elemento de la estructura, cada elemento

se denomina campo, en el ejemplo hay 5 campos.

2 CAPITULO 1. MANIPULACION DE ARCHIVOS ESTRUCTURADOS

Figura 1.1: Vista lgica de un archivo de registros de libros.

ISBN: un entero

TITULO: cadena de 20

AUTOR: cadena de 20

ANIO EDICION: entero

EDITORIAL: cadena de 20

La implementacin en C o C++ es como sigue:

typedef struct Libro

int ISBN;

char titulo[20];
char autor[20];

int anio;

char editorial[20];

}TLibro;

Donde TLibro se utiliza como un nuevo tipo de dato que representa un tipo para cada libro,
entonces un libro en particular se puede definir como:

LIBRO miLibro; y para acceder a cada uno de sus campos utilizaremos el operador punto
(.), por ejemplo:

miLibro.ISBN=2344;

miLibro.titulo="C y C++";

miLibro.autor="D. Ritchie";

miLibro.anio=1999;

miLibro.editorial="Alfa";

Ahora, utilizaremos un archivo para guardar cada registro, esto lo veremos

en la siguiente seccin.

1.3. OPERACIONES CON ARCHIVOS 3

1.3. Operaciones con archivos

Para manipular un archivo utilizaremos el tipo FILE (en realidad crearemos un puntero de
tipo FILE) y usaremos las siguientes funciones de stdlib.h.

fopen: Para abrir un archivo y asociarlo con un puntero de tipo FILE. La sintaxis es como
sigue:

FILE *fopen(char *nombre, char *modo) donde nombre es el nombre del archivo, en el que
se puede incluir la ruta y modo indica la forma en que puede usarse el archivo: w Para
crear un archivo. r Para leer un archivo. a Para aadir datos al archivo.

Ejemplo:

FILE *f = fopen("libros.txt","r");

fread: Lee datos del archivo y los pasa a la memoria principal.

fread(void *puntero, size_t tamanyo, size_t nmemb, FILE *f) donde puntero indica el espacio
de memoria en dnde se almacenarn los datos, tamanyo es la cantidad de bytes a leer,
nmemb es la cantidad de veces que se leera (asumiremos igual a 1), y f representa el
archivo.

fwrite: Lee datos de la memoria principal y los pasa al archivo.

fwrite(void *puntero, size_t tamanyo, size_t nmemb, FILE *f) donde puntero indica el
espacio de memoria desde dnde se leern los datos, tamao es la cantidad de bytes a
escribir, nmemb es la cantidad de veces que se escribirn (asumiremos igual a 1), y f
representa el archivo.

fseek: Permite ubicarnos en cualquier posicion del archivo para actualizar datos.

int fseek(FILE *f, long int desplazamiento, int origen);

La funcin fseek activa el indicador de posicin de ficheros de f y los desplaza seun el

parmetro desplazamiento donde la posicin inicial es origen. Se puede utilizar las
constantes SEEK SET para indicar como origen el inicio, SEEK CUR en caso de que origen
sea la posicin actual y SEEK END si es el final. Frecuentemente desplazamiento es un
valor obtenido mediante una llamada a la funcin ftell. Por ejemplo, si se tiene la posicin
de un registro X, entonces en cualquier momento podemos regresar a ubicarnos en ese
registro y actualizar sus datos. ftell: La funcin ftell obtiene el valor actual del indicador de
posicin de fichero para un determinado archivo. long int ftell(FILE *f);

4 CAPITULO 1. MANIPULACION DE ARCHIVOS ESTRUCTURADOS

1.4. Implementacion de las operaciones

Siguiendo con nuestra poltica de implementar un programa modularmente, crearemos dos

mdulos, uno para guardar un registro y otro para reportar todos los registros del archivo.

GUARDAR

void guardarLibro(TLibro L, FILE *f)

fwrite(&L,sizeof(TLibro),1,f);

REPORTAR

void reportarLibro(char *file)

FILE *f=fopen(file,"r");
TLibro L;

if (f!=NULL)

fread(&L,sizeof(TLibro),1,f);

while(!feof(f))

imprimir(L);

fread(&L,sizeof(TLibro),1,f);

else

printf( "Error al abrir el archivo \n" );

exit(1);

fclose(f);

En el mdulo anterior usamos la funcin feof() para determinar si ya se ha ledo el final del
archivo. Adems usamos el mdulo imprimir para mostrar los datos:

Void imprimir(TLibro L)

printf("ISBN : %s \n", L.ISBN);

printf("Titulo: %s \n", L.titulo);

printf("Anio : %s \n", L.autor);

printf("Anio : %d \n", L.anio);

printf("Anio : %s \n", L.editorial);

Cmo crear un archivo de acceso directo:

/* Creacion de un archivo de acceso directo */
#include (stdio.h)
#include (conio.h)
structDatosCliente
{
int cuenta;
char apellido[15];
char nombre[10];
float saldo;
};
main( )
{
int i;
structDatosClienteclienteNulo = {0,"","",0.0};
FILE *cuentaPtr;
if ((cuentaPtr = fopen("cliente.dat","w")) == NULL)
printf("No se puede abrir el archivo\n");
else
{
/* Escritura de 100 registros en blanco*/
for (i=1; i<= 100; i++)
fwrite(&clienteNulo, sizeof(structDatosCliente),1, cuentaPtr);
fclose(cuentaPtr);
}
getch ( );
return 0;