PIPO DE VARIABLE Carcter Entero Entero corto Entero largo Carcter sin signo Entero sin signo Entero

corto sin signo Entero largo sin signo Flotante de precisin sencilla Flotante de precisin doble

PALABRA CLAVE char int short long unsigned char unsigned int unsigned short unsigned long float double

BYTES REQUERIDOS 1 2 2 4 1 2 2 4 4 8

RANGO -128 a 127 -32768 a 32767 -32768 a 32767 -2147483648 a 2147483647 0 a 255 0 a 65535 0 a 65535 0 a 4294967295 1,2x10-38 a 3.4x1038 Precisin 7 dgitos 22x10-308 a 1.8x10308 Precisin 7 dgitos

TYPEDEF Permite crear un sinnimo para un tipo de dato existente: typedef int entero; entero contador; // crea entero como sinnimo de int // crea variable contador de tipo int

DECLARACION DE CONSTANTES SIMBOLICAS Se pueden crear con las directivas #define y const #define #define EJEMPLO 8 //crea constante EJEMPLO cargada con valor //constante 8 const const int ejemplo = 8; //crea constante ejemplo tipo int inicializada con 8, //constante inmodificable const float prueba1=10, int prueba2=20; // crea constante prueba1 tipo float //y constante prueba2 tipo int dentro //de misma lnea

OPERADOR CONDICIONAL z = (x > y) ? 1 : 100; //si x mayor q y hace z = 1 //si x no es mayor q y hace z =100

FUNCIONES Una funcin puede ser llamada desde el interior de de otra funcin Prototipo De Funcin
Tipo_de_retorno nombre_de_funcion (tipo de argumento1, ..., tipo de argumento n);

El prototipo por lo general va al encabezado del programa Debe incluir el tipo de las variables de los argumentos q se pasaran a la funcin, opcionalmente puede contener el nombre de las variables q sern pasadas Si no toma ningn argumento, dentro del parntesis se escribe void Ejemplos: double miFuncion(int); double miFuncion(int variable); Se define funcin miFuncion, la cual retorna un valor double; se puede escribir o no el nombre de la variable q pasara como argumento. void miFuncion(int, float, char); Se define funcin miFuncion, la cual no retorna ningn valor (void); toma tres argumentos de diferentes tipos (int, float, char). Int miFuncion(void); Se define funcin miFuncion, la cual retorna un valor tipo int; no toma argumento (void). ningn

Definicin De La Funcin
Tipo_de_retorno nombre_de_funcion (tipo de argumento1 nombre1, ..., tipo de argumento n nombre n) { enunciados}

Es la primera lnea de la funcin. Los nombres de las variables que pasan como argumentos deben ser incluidos (puede ser el mismo nombre de la variable q se toma del otro programa o cualquier otro nombre si se pone otro nombre queda definido ese nombre como variable local de la funcin). Siempre y cuando el tipo de retorno de la funcin sea diferente a void, se debe incluir el enunciado return para regresar un valor de acuerdo al tipo de retorno establecido Ejemplos: return ( a + b); Retorna el valor de la suma de las variables a + b. if (a>b) return a; else return b; En una funcin puede haber ms de un return como muestra el ejemplo.

Paso De Argumentos Un argumento puede ser cualquier expresin valida como constante, variables expresiones matemticas u otras funciones Ejemplos: Teniendo ya definida la funcin miFuncion(): x = miFuncion(); x toma como valor el retorno de de la funcin miFuncion Se tienen definidas las funciones primera y segunda x = (segunda(primera(y))); El programa primero llama la funcin primera, la cual tiene como argumento el valor de la variable y; el valor de retorno de la funcin primera es tomado como argumento para la funcin segunda la cual se ejecuta y el retorno de esta es el valor q toma la variable x.

Llamado De Funciones Se puede llamar una funcion desde cualquier lugar en el q se pueda usar una expresin Ejemplos: Teniendo definida la funcion miFuncion (q retorna entero) y la variable x (entera) printf( valor variable %d, valor funcin %d,x, miFuncion(x)); El printf imprime el retorno de la funcin miFuncion la cual toma como argumento a la variable x Teniendo definidas las variables x, y, z y las funciones miFuncion1 y miFuncion2 x = miFuncion1(y) + miFuncion2(z) El valor de x es la suma del retorno de miFuncion1 (q toma como argumento a la variable y) mas el retorno de miFuncion2 (la cual toma como retorno a la variable z); Teniendo definida la funcion miFuncion y la variable x If(miFuncion(x) >10) { Enunciados; } Se evala si el retorno de miFuncion (q toma como argumento a la variable x) es mayor q 10.

APUNTADORES Un apuntador es una variable que contiene la direccin de memoria de otra variable. DECLARACIN: Tipo_de_dato *nombre apuntador Tipo de dato: int, float, char, duble; indica el tipo de variable a la que apunta *: Operador de indireccion Nombre apuntador: Cualquier nombre q se quiera dar al puntero Inicializacion. apuntador = &variable; Para inicializar un apuntador se antepone & (operador de direccin) para que en el apuntador quede almacenada la direccin de memoria de la variable. Direccin indireccion: Suponiendo q tenemos declarado el apuntador miApuntador y la miVariable: *miApuntador y miVariable hacen referencia al valor almacenado en la variable miVariable. miApuntador y &miVariable hacen referencia a la direccin de memoria de la variable miVariable OPERACIONES: apuntador1 apuntador2; Muestra la distancia entre los dos apuntadores; solo es valido si apuntan a un mismo arreglo (vector o matriz).

*apuntador++ *apuntador--

EL incremento y el decremento son validos; Al incrementar el apuntador no se incrementa el valor de este en unidades, se incrementa es en posiciones de memoria

Operaciones de comparacin (==, !=, >, <) son validos entre apuntadores que apuntan al mismo arreglo. La multiplicacin y la divisin no son validas entre apuntadores. APUNTADORES, ARREGLOS Y FUNCIONES: El nombre de un arreglo sin el subndice es un apuntador al primer elemento del arreglo (vector o matriz), por lo tanto: int miVector = int *miVector *(arreglo) = arreglo[0]; *(arreglo + 1) = arreglo[1]; ................. *(arreglo + n) = arreglo[n];

La nica forma de pasar un arreglo como argumento de una funcin es mediante apuntadores; Ejemplo: int miArreglo[10]; //se declara arreglo miArreglo de 10 posiciones int miFuncion(int x[]); /* prototipo de funcin miFuncion, se indica q como argumenta se para un apuntador a un arreglo tipo int. Tambin se pudo escribir as: int miFuncion(int *x);*/ miFuncion(miArreglo); //Llamado de funcin int miFuncion(int x[]); //definicin de funcin Apuntadores A Apuntadores Se puede crear un a variable q cuyo valor sea la direccin de un apuntador (apuntador a apuntador): int variable; int *puntero = &variable; /*Puntero es inicializado con la direccin de variable*/ int **puntero2 = &puntero; /*puntero2 es inicializado con la direccin de puntero; Como apunta a la direccin de un apuntador se usa doble operador de indireccion*/ **puntero2 = 12; /*Asigna el 12 a variable; uso doble operador de indireccion*/ Apuntadores De Varias Dimensiones int miArreglo[2][4]; //Declaro arreglo de 2 grupos c/u con 4 enteros int (*puntero )[4]; //Declaro apuntador q puede apuntar a 4 elementos tipo int puntero = miArreglo; /*puntero apunta al miArreglo[0], es decir al primer grupo de 4 enteros*/ puntero++; //Al incrementar puntero hace q este apunte al segundo grupo de 4 enteros, equivale a puntero = &miArreglo[1] VARIABLES DE CARACTER Para inicializar (o cargar) un valor en una variable char se debe incluir el carcter dentro de comillas simples: char miVariable = c; //declara variable tipo char miVariable y la carga //con la letra c Se pueden crear constantes simblicas de caracteres: #define TAM t //en ambos casos se define la constante TAM const char TAM = t; //cargada con le letra t se puede cargar un valor numrica en una variable tipo char, y este la asocia con el cdigo ASCCI al q hace referencia dicho valor numrico: char miVariable = 90; //almacena la letra Z en miVariable cuyo cdigo //ASCII es el 90 Los caracteres estndares ASCII van hasta el 127. Los caracteres q van del 128 al 255 son caracteres ASCCI extendidos y deben almacenar en variables tipo unsigned char.

CADENAS DE CARACTERES Arreglos Las cadenas de caracteres son arreglos de caracteres q termina en el carcter nulo \0 o NULL. char cadena [8] = ejemplo; Se declara arreglo tipo char de 8 posiciones la cual se inicializa con una palabra de solo 7 caracteres (ejemplo) para q en la 8ava posicin del arreglo se almacene el carcter nulo (\o o NULL) el cual indica el fin de la cadena Las arreglos tambin se pueden inicializar dando valor posicin a posicin: char cadena [5] = {p,e,r,r,o,\0}; Se ve q en la ultima posicin se almaceno tambin el valor nulo (\0) para indicar el fin de la cadena.

Apuntador _ arreglo Usando la funcin malloc podemos crear un apuntador que almacene una cadena; la ventaja de esto es que el apuntador toma el espacio e memoria q se necesita para guardar la cadena (ni mas ni menos) #include <stdlib.h> //librera q contiene a malloc char *cadena; //declaro apuntador cadena cadena = (char*)malloc(100); //asigna 100 posiciones de memoria c//u de //1byte(char*, = 1byte) cadena = mensaje de prueba; //Esta instruccin guarda la cadena mensaje de prueba en alguna posicin e memoria y hace q el apuntador cadena apunta a la direccin de memoria del primer carcter.

cadena = (char*)malloc(50 * sizeof(char)); se asignan 50 posiciones (50 * 1byte q es el tamo de un char) de un 1 byte c/u (char*) int cadena = (int*) malloc(sizeof(int)*TAM); Se puede implementa r para cualquier tipo de apuntador; Ac TAM es una constante definida #DEFINE TAM 50 malloc(sizeof(int)*TAM); = crea 20 espacios de memoria = malloc(20) (int*) = c/u de las 20 posiciones tiene un tamao de 2bytes q es el tamao de int Entrada de cadenas usando scanf scanf(%s%s,cadena1,cadena2;) no usa & ya q este solo se usa al ingresar datos numricos Pasa los primeros caracteres a cadena1 hasta q encuentre un espacio en blanco

Pasa los caracteres q estn despus del primer espacio en blanco a cadena2 scanf(%4s%3s,cadena1,cadena2); Pasa los primeros 4 caracteres digitados a cadena1 Pasa los siguientes 3 caracteres (del 5 al 7) a cadena2 Arreglo De Apuntadores char *puntero[5] = {uno, dos, tres}; /*declara un arreglo de 5 elementos; cada elementos es un apuntador a tipo char; los tres primeros elementos del arreglo.*/ puntero[0] apunta al primer carcter de la cadena uno puntero[1] apunta al primer carcter de la cadena dos puntero[2] apunta al primer carcter de la cadena tres ESTRUCTURAS ES una agrupacin, bajo un mismo nombre, de una o mas variables. Definicin struct miEstructura { int a; float b; char c; }; /*define estructura llamada miEstructura puede contener cualquier tipo y cantidad de variables*/

Declaracin struct miEstructura instancia1

/*Declara tipo de estructura instancia1 del tipo miEstructura*/ instancia1 es una estructura, la cual contiene la variable a (tipo int), la variable b (tipo float) y la variable c (tipo char), definidas previamente. Acceso A Miembros De La Estructura Para acceder alo s miembros de la estructura se usa el operador punto (.); se posiciona entre el nombre de la estructura y el nombre del miembro as. miEstructura.c instancia1.a = 100; //hace a=100 printf(%f;instancia1.b); //imprime contenido de variable b Estructuras Q Contienen Estructuras En C no hay limite para el anidamiento de estructuras struct miEstructura /*define estructura llamada miEstructura { int a; char c; }; struct anidada { struct miEstructura /* define estructura llamada anidada q contiene dos variables tipo struct miEstructura*/

primer;

struct miEstructura segundo; }; struct anidada intancia1; instancia1.primer.a =10; instancia1.primer.c++; instancia1.segundo.a --; instancia1.segundo.c = 0; /* defino instancia1 del tipo struct anidada */ /* para acceder a c/u de los miembros de instancia1 se debe usa r doble vez el operador punto (.); se manejan como cualquier otra variable */

Estructuras Que Contienen Arreglos struct miEstructura //define estructura llamada miEstructura { int a[20]; float b[10]; }instancia2; //declaro instancia2 del tipo struct miEstructura instancia2.a[3] = 14; //en posicin 04 de a almaceno 14 instancia2.b[5] = 1.2; // en posicin 5 de b almaceno 1.2 Para acceso a una posicin de memoria del arreglo contenido en la estructura simplemente porgo entre corchetes el nmero de la posicin a acceder. Arreglos De Estructuras struct miEstructura { int a[5]; char c[6]; }; /*define estructura llamada miEstructura

struct miEstructura arregloEst[10]; /*Define arreglo de 10 posiciones tipo miEstructura; c/u de las posiciones del arreglo contiene una variable int a y char c (en total 10 int a y char c)*/ arregloEst[2] = arregloEst[8]; /*copia contenido de la posicion 02 a la 08 del arreglo (incluye toda las variables dentro del arreglo)*/ arregloEst[0].a[0] = arregloEst[3]. a[1]; de los arreglos /*Mueve datos entre elementos individuales

Inicializacin De Estructuras struct miEstructura //define estructura llamada miEstructura { char a[20]; int b; }instancia2= {juan camilo,200}; //declaro instancia2 del tipo struct //miEstructura Inicializa a instancia2.a con la cadena juan camilo Inicializa a instancia2.b con el # 200 Apuntadores Como Miembros De Cadenas

struct miEstructura { char *puntero }instancia1; char variable1;

//define estructura llamada miEstructura //declara apuntador a tipo char puntero //defino variable tipo char //inicio el apuntador para q apunte a variable tipo //char;

instancia1.puntero = &variable1;

Otra forma de iniciar el apuntador tipo char es: instancia1.puntero = apenad c en 21 das; instancia1.puntero apunta a la direccin de memoria de la cadena apenad c en 21 das Apuntadores A Estructuras struct miEstructura //define estructura llamada miEstructura { int numero char nombre }instancia1; //declaro instancia1 del tipo struct miEstructura struct miEstructura *puntero //Declaro apuntador puntero al tipo struct miEstructura puntero = instancia1; //inicio apuntador puntero con la direccin de memoria de estructura instancia1 q es del mismo tipo al cual apunta puntero (struct miEstructura) Para acceder por ejemplo a instancia.numero mediante el apuntador se tiene dos formas (*puntero).numero=100; //Usando el operador de desreferenciacion (*). El nombre //del apuntador derefenciado debe ir en parntesis Puntero->numero=100; //Usando el operador de membresa indirecta (guin y //mayor que;

Apuntadores A Arreglos De Estructuras struct miEstructura /*define estructura llamada miEstructura { int a; }; struct miEstructura arregloEst[10]; miEstructura/* struct miEstructura *puntero /*Define arreglo de 10 posiciones tipo //defino apuntador *puntero al tipo struct //miEstructura

puntero = & arregloEst[3]; //Inicializo puntero con la direccin de memoria de //arregloEst[3] Para cambiar el elemento del arreglo a la q apunta el apuntador puntero podemos modificarlo con:

puntero++; puntero--;

/* Segn aritmtica de apuntadores estas expresiones equivalen a puntero+=sizeof(obj); y puntero-=sizeof(obj); respectivamente

Estructuras Como Argumento De una Funcin struct miEstructura /*define estructura llamada miEstructura { int a; }instancia1; void miFuncion(struct miEstructura) /*Prototipo de funcin miFUncion; no retorna ningn valor pero toma como argumento una estructura tipo miEstructura EL llamado del a funcin se hace como cualquier otra funcin void miFuncion(struct miEstructura instancia1) /*declaracin de funcin { Argumentos } Lista Encadenada Una lista encadenada es una serie de estructuras relacionadas secuencialmente median te apuntadores. Cada Lista tiene un inicio y un final: El inicio es un apuntador q apunta a la primera estructura de las lista (apuntador al tipo de dato que forma la lista) El final se da en una estructura q contiene un apuntador a NULL.

Funcin malloc() Se usa para asignar memoria a una estructura struct miEstructura /*define estructura llamada miEstructura { int a; }; struct miEstructura *puntero //Declaro apuntador puntero al tipo struct miEstructura puntero=malloc(sizeof(struct miEstructura)); /*asigna un bloque de acuerdo a la memoria q necesite la estructura, regresando en puntero la direccin de memoria de dicho bloque. En caso q no se pueda asignar el tamao de memoria se carga en puntero el valor NULL.*/ puntero->a; /*Para el acceso a los miembros de la estructura se debe usar el operador de membresa indirecta(->) . No se puede usar el operador punto ya q al usar este

mtodo no se declara ninguna instancia, se trabaja directamente sobre direccin de memoria de la estructura (apuntador). ALCANCE DE LAS VARIABLES Las variables locales NO son inicializadas a cero automticamente por le compilador Variables Estticas y Automticas Estos conceptos se aplican a variables declaradas dentro de alguna funcin auxiliar (no aplica para variables de la funcin main) Una variable local es por defecto una variable automtica, es decir q no guarda su valor entre llamadas de la funcin q la contiene Una variable esttica conserva su valor entre llamadas de la funcin q la contiene (no pierde su valor); una variable esttica solo es inicializada la primer q la funcin es llamada, en llamada posteriores el programa recuerda q la variable ya fue inicializada y no la vuelve a inicializar: { static int miVariable=0; /*Define variable esttica miVariable; la inicializacin miVariable++; en este acaso a cero, solo se ejecuta la primer vez q se llama la funcin q la contiene; } CONTROL DEL PROGRAMA EXPRESION FOR Se puede omitir la expresion de inicializacin: for( ; contador<100; contador++) LA primera expresin no necesariamente debe ser de inicializacin, puede ser cualquier otra expresin de C: for(printf(Mensaje de prueba ; contador<100; contador++) La expresin print solo se ejecutara una vez, cuando el for se ejecuta por primera vez Se pueden usar operadores lgicos y omitir la tercera expresin for(printf(cont = 0 ; contador<100 && i>100 ; ) Se pueden inicializar y modificar dos variables: for(printf(i = 0, j=100 ; i<100 ;i++, j-- ) EXPRESION DO......WHILE Sintaxis: do { Enunciados

}while(condicin); Los enunciados del ciclo se ejecutan por lo menos una vez, ya que la condicin es avaluada al final del enunciado al contrario de while y for que primero evalan la condicin y despus ejecutan o no los enunciados. SECUENCIAS DE ESCAPE
SECUENCIA \a \b \n \t \\ \? \ \ SIGNIFICADO Campana (alerta) Retroceso Nueva lnea Tabulador horizontal Diagonal inversa \ Signo de interrogacin Comilla simple Comilla doble

ESPECIFICADORES DE CONVERSION
ESPECIFICADOR %c %d %f %s %u SIGNIFICADO Un solo carcter Entero decimal con signo int y long Nmero decimal con punto flotante float y double Cadena de caracteres Entero decimal sin signo unsigned int y unsigned long

Enunciado break Solo se puede poner dentro de ciclos for, while, do while o switch. Hace q el ciclo finalice de inmediato. El programa ejecuta la instruccin q se encuentre despus del ciclo Enunciado continue Solo se puede poner dentro de ciclos for, while, do while o switch. Hace q el control del programa se salte el resto de la itineracion actual i comience una itineracion nueva del ciclo, es decir corta la ejecucin actual del ciclo. Enunciado goto Genera un salto incondicional a una etiqueta: goto etiqueta1; /*salto a etiqueta1 etiqueta1:; /*e l nombre de la etiqueta debe estar seguido de dos puntos Enjunciado; (:) y punto y coma (;)*/ goto y la etiqueta de destino deben estar en la misma funci0on. Ciclos Infinitos while(1) { Enunciados; }

for(;;) { Enunciados; } do { Enunciados; }while(1): La Utilidad de un ciclo infinito se logra implementndolo junto con el en enunciado break. Enunciado switch Switch(miVariable) { case 01: /*si miVariable = 01 el programa se ejecuta desde ac en enunciados; adelante*/ case 02: /*si miVariable = 02 el programa se ejecuta desde ac en enunciados; adelante*/ default: /*si mivariable es diferente de 1 y 2 el programa se ejecuta enunciados; desde ac*/ } No necesariamente las plantillas case deben evaluar con un numero , pueden tambin compara con otro valor o expresin(igual q if). Se puede poner un enunciado break al final de cada plantilla para q el programa no ejecute la siguiente plantilla. Funcin exit Se usa para finalizar el programa en cualquier punto o momento exit (0); //Para indicar q se finaliza programa sin ningn error exit(1) ; / Para indicar q el programa finalizo con errores Para usar exit se debe incluir la biblioteca STLIB.H Ejecucin de comandos de SO Se usa la funcin system(), de la biblioteca STLIB.H system(dir); //ejecuta el comando dir de DOS Usando la funcin system(), se puede ejecutar cualquier archivo ejecutable. TRABAJO CON PANTALLA, IMPRESORA Y TECLADO Flujo Un flujo es una secuencia de bytes de datos. Los flujos pueden ser de texto o binarios

Los flujos predefinidos en C son los siguientes:

NOMBRE stdin stdout stderr stdrn stdaux FLUJO Entrada estndar Salida estndar Error estndar Impresora estndar Auxiliar estndar DISPOSITIVO Teclado Pantalla Pantalla Puerto LPT1 Puerto COM1

Funciones De Flujo Las funciones de entrada/salida vienen en pares; las que usan los flujos estndar o predefinidos y las q requieren especificacin del flujo (por parte del programador) a usar:
USA FLUJOS ESTANDAR printf vprintf puts putchar scanf gets getchar perror USA FLUJOS ESPECIFICADO fprintf vfprintf fputs putc, fputc fscanf fgets getc, fgetc ACCION Salida formateada Salida formateada con lista variable de argumentos Salida de cadena Salida de carcter Entrada formateada Entrada de cadena Entrada de carcter Solo salida e cadena a stderr

Algunas funciones, para indicar error, devuelven al programa la constante simblica EOF, la cual esta en la librera stdio.h y tiene un valor de -1. Funcin getchar Obtiene el siguiente carcter del flujo stdin (teclado), cada vez q es llamada While((miVariable = getchar())=\n) /*Almacena uno a uno los caracteres { tecleados en miVariable hasta q se Argumentos; encuentre una nueva lnea (\n)*/ }

Funcin gets Obtiene una cadena de caracteres del flujo stdin (teclado) y la guarda en una cadena Funcin fgets Obtiene una cadena de caracteres de la cantidad de caracteres y flujo de entrada especificado por el programador . Lee caracteres de entrada hasta encontrar una nueva lnea, un fin de archivo u obtener la cantidad de caracteres especificada fgets(miArreglo, 10, puntero); /*guarda en miArreglo 10 caracteres tomados desde puntero q puede ser un apuntador a un archivo previamente defini*/ Funcin scanf puts(escriba 5 dgitos); /*Pide 5digitos

scanf(%2d%3d,&miVariable1,miVariable2);

con los especificadores de ancho %2d %3d separa los 5 dgitos de entrada en dos grupos, un grupo de 2 q se almacena en miVariable1 y uno de 3 q almacena en miVariable2*/ puts(escriba 2 palabras separadas por un espacio); /*pide 2 palabras scanf([^ ],&miArreglo1,miArreglo2); /*con el especificador [^ ] corta la cadena cuando encuentra un espacio en blanco, la primer parte la almacena en miArreglo1 , la segunda la almacena en miArreglo2 Funcin putchar Enva el siguiente caracter al flujo estndar de salida stdout (pantalla)cada vez q es llamada. putchar(miVariable);/*imprime en pantalla caracter almacenado en mi variable Funciones putc() y fputc() Envan un carcter al flujo de salida especificado. fputc(`c`, flujo especificado); /*Enva el carcter c a el flujo de salida especificado, puede ser un apuntador a un archivo abierto*/ Funcin puts Imprime una cadena en el flujo de salida estndar stdout (pantalla) puts(miArreglo); //Imprime el contenido de miArreglo puts(mensaje de prueba) //Imprime la cadena mensaje de prueba Funcin fputs Imprime una cadena en el flujo establecido por el programador fputs(miArreglo, flujo especificado) /*Imprime el contenido de miArreglo (cadena) en el flujo especificado, el cual puede ser un apuntador a un archivo*/ Funcin fprintf Se usa para salida formateada hacia el flujo de salida especificado por el programador, puede ser el apuntador a un archivo Fprintf(stdprn,Mensaje de prueba); /*enva mensaje de prueba al flujo stdprn (impresora pto LPT1)*/ USO DE ARCHIVOS DE DISCO Para trabajar con archivos de disco se debe usar un apuntador a tipo file y luego inicializarlo con la direccin de memoria del archivo a usar FILE *fp Tipo de Archivos De Disco Flujo de texto: Secuencia de lneas, donde cada lnea contiene cero o ms caracteres y termina con uno o ms caracteres que indican el fin de la lnea. La longitud mxima de la lnea son 255 caracteres. Una lnea no es una cadena debido a q no lleva caracter NULL. Flujo binario: Son los dems tipo de archivo (diferente de texto). Los datos son es escritos y ledos sin cambio

Los nombres de los archivos son guardados en cadenas

Apertura De Archivos Para abrir archivos se usa la funcin fopen de la biblioteca STDIO.H Si al abrir u n archivo ocurre un error fopen regresa NULL fopen(nombre de archivo, modo de apertura) /*modo es el especificado de como se va a abrir el archivo:*/
MODO r W A R+ W+ A+ SIGNIFICADO Abre el archivo para lectura Escritura. Si el archivo no existe lo crea en disco. Si ya existe borra todos los datos q contiene adicin. Si el archivo no existe lo crea en disco. Si ya existe aade nvos datos al final del archivo Lectura y escritura. Si el archivo no existe lo crea en disco. Si ya existe aade nvos datos al inicio sobrescribiendo (borrando) los datos q contiene el archivo Lectura y escritura. Si el archivo no existe lo crea en disco. Si existe es sobrescrito Lectura y adicin. Si el archivo no existe lo crea en disco. Si existe los datos son aadidos al final (no borra ningn dato)

Si se quiere trabajar con archivos binarios solo debemos anteponer la letra b a los anteriores modos de apertura FILE *fp //declaro apuntador a tipo FIle fp = fopen(archivo.txt,a+); //abre archivo en modo de adicin fclose(fp); //cierra archivo (apuntador a tipo FILE) Entrada y Salida De Archivos Formateados Se usa para archivos con datos de texto y nmeros q vayan a ser ledos por y desde otros programas (hojas de calcula, bases de dato) La salida formateada se da con la funcin fprintf de la biblioteca STDIO.H fpintf(fp, %d %c,miVariable,miArreglo[0]); /*fp es el apuntador al archivo previamente abierto; Se imprime en archivo los valores almacenados en miVariable y en miArreglo[0]*/ La entrada formateada se da con la funcin fscanf: fscanf(fp, %d %c,miVariable,miArreglo[0]); /*fp es el apuntador al archivo previamente abierto; Se almacena caracteres ledos en miVariable y en miArreglo[0]*/ ENTRADA Y SALIDA DE CARACTERES Hace referencia a lneas de caracteres y caracteres individuales. Se debe usar para manejo de archivos de texto Entrada/Salida De Un Caracter Para la entrada de un carcter se usa la funcin gets o fgets, cuyo funcionamiento es el mismo, de la biblioteca STDIO.H getc(fp); //Donde fp es el apuntador al archivo previamente abierto. Para la salida de un caracter se usa la funcin putc de la biblioteca STDIO.H fputc(`c`, fp); /*Enva el carcter c a fp q es el apuntador al archivo previamente abierto*/

Entrada/Salida De lneas De Caracteres Para la entrada de lneas de caracteres se usa la funcin fgets. fgets(miArreglo, 10, fp); /*guarda en miArreglo 10 caracteres tomados desde apuntador a archivo */ Para la salida de caracteres se usa la funcin fputs fputs(miArreglo, fp) /*Imprime el contenido de miArreglo (cadena) en el apuntador a archivo fp*/ fputs no aade cambio de lnea. ENTRADA Y SALIDA DIRECTAS Se usa solamente con archivos binarios y principalmente en archivos q van a ser ledos posteriormente en c.