Professional Documents
Culture Documents
LENGUAJE C
1.- Caractersticas del lenguaje C 2.- Estructura de un programa en C 2.1.- Estructura 2.2.- Comentarios 2.3.- Palabras clave 2.4.- Identificadores 3.- Tipos de datos 3.1.- Tipos 3.2.- Calificadores de tipo 3.3.- Las variables 3.4.- Dnde se declaran ? 3.5.- Constantes 3.6.- Secuencias de escape 3.7.- Inclusin de ficheros 4.- Operadores aritmticos y de asignacin 4.1.- Operadores artmeticos 4.2.- Operadores de asignacin 4.3.- Jerarqua de los operadores 5.- Salida / Entrada 5.1.- Sentencia printf() 5.2.- Sentencia scanf() 6.- Operadores relacionales 7.- Sentencias condicionales 7.1.- Estructura IF...ELSE 7.2.- Estructura SWITCH 8.- Operadores lgicos 9.- Bucles 9.1.- Sentencia WHILE 9.2.- Sentencia DO...WHILE 9.3.- Sentencia FOR 9.4.- Sentencia BREAK 9.5.- Sentencia CONTINUE 10.- Funciones 10.1.- Tiempo de vida de los datos 10.2.- Funciones 10.3.- Declaracin de las funciones 10.4.- Paso de parmetros a una funcin 11.- Arrays 11.1.- Vectores 11.2.- Matrices 12.- Punteros 12.1.- Declaracin 12.2.- Operadores 12.3.- Asignacin 12.4.- Aritmtica de direcciones 13.- Estructuras 13.1.- Concepto de estructura 13.2.- Estructuras y funciones 13.3.- Arrays de estructuras 13.4.- Typedef 14.- Ficheros 14.1.- Apertura 14.2.- Cierre 14.3.- Escritura y lectura 15.- Gestin dinmica de memoria 15.1.- Funciones 15.2.- Estructuras dinmicas de datos 16.- Programas de aplicacin
Podemos decir que el lenguaje C es un lenguaje de nivel medio, ya que combina elementos de lenguaje de alto nivel con la funcionalidad del lenguaje ensamblador. Es un lenguaje estructurado, ya que per mite crear procedimientos en bloques dentro de otros procedimientos. Hay que destacar que el C es un lenguaje portable, ya que permite utilizar el mismo cdigo en diferentes equipos y sistemas informticos: el lenguaje es independiente de la arquitectura d e cualquier mquina en particular.
Por ltimo solo queda decir que el C es un lenguaje relativamente pequeo; se puede describir en poco espacio y aprender rpidamente. Este es sin duda el objetivo de ste curso. No pretende ser un completo manual de la p rogramacin, sin una base til para que cualquiera pueda introducirse e n este apasionante mundo.
Aunque en principio cualquier compilador de C es vlido, para seguir este curso se recomienda utilizar el compilador Turbo C/C++ o bien el Borland C++ 5.0 .
2. ESTRUCTURA DE UN UN PROGRAMA EN C
2.1.- Estructura Todo programa en C consta de una o ms funciones, una de las cuales se llama main. El programa comienza en la funcin main, desde la cual es posible llamar a otras funciones. Cada funcin estar formada por la cabecera de la funcin, compuesta por el nombre de la misma y la lista de argumentos (si los hubiese), la declaracin de las variables a utilizar y la secuencia de sentencias a ejecutar. Ejemplo: declaraciones globales main( ) { } variables locales bloque
funcion1( ) { variables locales bloque } 2.2.- Comentarios A la hora de programar es conveniente aadir comentarios (cuantos ms mejor) para poder saber que funcin tiene cada parte del cdigo, en caso de que no lo utilicemos durante algn tiempo. Adems facilitaremos el trabajo a otros programadores que puedan utilizar nuestro archivo fuente. Para poner comentarios en un programa escrito en C usamos los smbolos /* y */: /* Este es un ejemplo de coment ario */ /* Un comentario tambin puede estar escrito en varias lneas */
El smbolo /* se coloca al principio del comentario y el smbolo */ al final. El comentario, contenido entre estos dos smbolos, no ser tenido en cuenta por el compilador.
2.3.- Palabras clave Existen una serie de indicadores reservados, con una finalidad determinada, que no podemos utilizar como identificadores.
A continuacin vemos algunas de estas palabras clave: char else short continue int do long break float while extern register double for static sizeof if switch default typedef
2.4.- Identificadores Un identificador es el nombre que damos a las variables y funciones. Est formado por una secuencia de letras y dgitos, aunque tamb in acepta el caracter de subrayado _. Por contra no acepta los acentos ni la /. El primer caracter de un identificador no puede ser un nmero, es decir que debe ser una letra o el smbolo _. Se diferencian las maysculas de las minsculas, a s num, Num y nuM son distintos identificadores. A continuacin vemos algunos ejemplos de identificadores vlidos y no vlidos: Vlidos _num var1 fecha_nac No vlidos 1num nmero2 ao_nac
3. TIPOS DE DATOS
En 'C' existen bsicamente cuatro tipos de datos, aunque como se ver despus, podremos definir nuestros propios tipos de datos a partir de estos cuatro. A continuacin se detalla su nombre, el tamao que ocupa en memoria y el rango de sus posibles valores. TIPO char int float double Tamao 1 byte 2 bytes 4 bytes 8 bytes Rango de valores -128 a 127 -32768 a 32767 3. 4E-38 a 3.4 E+38 1.7 E-308 a 1.7 E+308
3.2.- Calificadores de tipo Los calificadores de tipo tienen la misin de modificar el rango de valores de un determinado tipo de variable. Estos calificadores son cuatro: signed Le indica a la variable que va a llevar signo. Es el utilizado por defecto. TIPO signed char signed int Tamao 1 byte 2 bytes Rango de valores -128 a 127 -32768 a 32767
unsigned Le indica a la variable que no va a llevar signo (valor absoluto). TIPO unsigned char unsigned int Tamao 1 byte 2 bytes Rango de valores 0 a 255 0 a 65535
short Rango de valores en formato corto (limitado). Es el utilizado por defecto. TIPO short char short int Tamao 1 byte 2 bytes Rango de valores -128 a 127 -32768 a 32767
long Rango de valores en formato largo (ampliado). TIPO long int long double Tamao 4 bytes 10 bytes Rango de valores -2.147.483.648 a 2.147.483.647 -3'36 E-4932 a 1'18 E+4932
Tambin es posible combinar calificadores entre s: signed long int = long int = long unsigned long int = unsigned long 3.3.- Las variables Una variable es un tipo de dato, referenciado mediante un identificador (que es el nombre de la variable). Su contenido podr ser modificado a lo largo del programa. Una variable slo puede pertenecer a un tipo de dato. Para poder utilizar una variable, primero tiene que ser declarada: [calificador] <tipo> <nombre> Es posible inicializar y declarar ms de una variable del mismo tipo en la misma sentencia: [calificador] <tipo>< nombre1>,<nombre2>=<va lor>,<nombre3>=<valor>, /* Uso de las variabl es */ #include <stdio.h> main() /* Suma dos valores */ { int num1=4,num2,num3=6; printf("El valor de num1 es %d",num1); printf("\nEl valor de num3 es %d",num3); num2=num1+num3; printf("\nnum1 + num3 = %d",num2); } 4 bytes 0 a 4.294.967.295 (El mayor entero permitido en 'C')
3.4.- Dnde se declaran ? Las variables pueden ser de dos tipos segn el lugar en que las declaremos: globales o
Facultad De Ingenieria de Sistemas Lenguaje C locales. La variable global se declara antes de la main( ). Puede ser utilizada en cualquier parte del programa y se destruye al finalizar ste. La variable local se declara despus de la main( ), en la funcin en que vaya a ser utilizada. Slo existe dentro de la funcin en que se declara y se destruye al finalizar dicha funcin. El identificador (nombre de la variable) no puede ser una palabra clave y los caracteres que podemos utilizar son las letras: a-z y A-Z (ojo! la o no est permitida), los nmeros: 0-9 y el smbolo de subrayado _. Adems hay que tener en cuenta que el primer caracter no puede ser un nmero.
/* Declaracin de variables */ #include <stdio.h> int a; main() /* Muestra dos valores */ { int b=4; printf("b es local y vale %d",b); a=5; printf("\na es global y vale %d",a); } 3.5.- Constantes Al contrario que las variables , las constantes mantienen su valor a lo largo de t odo el programa. Para indicar al compilador que se trata de una constante, usaremos la directiva #define : #define <identificador> <valor>
Observa que no se indica el punto y coma de final de sentencia ni tampoco el tipo de dato. La directiva #define no slo nos permite sustituir un nombre por un valor numrico, sin tambin por una cadena de caracteres. El valor de una constante no puede ser modificado de ninguna manera.
/* Uso de las constantes */ #include <stdio.h> #define pi 3.1416 #define escribe printf
/* Uso de las secuencias de escape */ #include <stdio.h> main() /* Escribe diversas sec. de escape */ { printf("Me llamo \"Nemo\" el grande"); printf("\nDireccin: C\\ Mayor 25"); printf("\nHa salido la letra \'L\'"); printf("\nRetroceso\b"); printf("\n\tEsto ha sido todo"); } 3.7.- Inclusin de ficheros En la programacin en C es posible utilizar funciones que no esten includas en el propio programa. Para ello utilizamos la dire ctiva #include , que nos permite aadir libreras o funciones que se encuentran en otros ficheros a nuestro programa. Para indicar al compilador que vamos a incluir ficheros externos podemos hacerlo de dos maneras (siempre antes de las declaraciones). 1. Indicndole al compilador la ruta donde se encuentra el fichero. #include "misfunc.h" #include "c:\includes\misfunc.h"
2. Indicando que se encuentran en el directorio por defecto del compilador. #include <misfunc.h>
/* Uso de los operadores aritmticos */ #include <stdio.h> main() /* Realiza varias operaciones */ { int a=1,b=2,c=3,r; r=a+b; printf("%d + %d = %d \n",a,b,r); r=c-a; printf("%d - %d = %d\n",c,a,r); b++; printf("b + 1 = %d",b); }
10
Con estos operadores se pueden escribir, de forma ms breve, expresiones del tipo: n=n+3 se puede escribir n+=3 k=k*(x-2) lo podemos sustituir por k*=x-2 /* Uso de los operadores de asignacin */ #include <stdio.h> main() /* Realiza varias operaciones */ { int a=1,b=2,c=3,r; a+=5; printf("a + 5 = %d \n",a); c-=1; printf("c - 1 = %d\n",c); b*=3; printf("b * 3 = %d",b); } 4.3.- Jerarqua de los operadores Ser importante tener en cuenta l a precedencia de los operadores a la hora de trabajar con ellos: () ++, - *, /, % +, Mayor precedencia Menor precendencia
Las operaciones con mayor precedencia se realizan antes que las de menor precedencia. Si en una operacin encont ramos signos del mismo nivel de precedencia, dicha operacin se realiza de izquierda a derecha. A continuacin se muestra un ejemplo sobre ello: a*b+c/d-e
11
Fijarse que la multiplicacin se resuelve antes que la divisin ya que est situada ms a la izquierda en la operacin. Lo mismo ocurre con la suma y la resta. /* Jerarqua de los operadores */ #include <stdio.h> main() /* Realiza una operacin */ { int a=6,b=5,c=4,d=2,e=1,x,y,z,r; x=a*b; printf("%d * %d = %d \n",a,b,x); y=c/d; printf("%d / %d = %d \n",c,d,y); z=x+y; printf("%d + %d = %d \n",x,y,z); r=z-e; printf("%d = %d",r,a*b+c/d -e); }
12
5. SALIDA Y ENTRADA
5.1.- Sentencia printf( ) La rutina printf permite la aparicin de valores numricos, caracteres y cadenas de texto por pantalla. El prototipo de la sentencia printf es el siguiente: printf(control,arg1,arg2...); En la cadena de control indicamos la forma en que se mostrarn los argument os posteriores. Tambin podemos introducir una cadena de texto ( sin necesidad de argumentos ), o combinar ambas posibilidades, as como secuencias de escape . En el caso de que utilicemos argumentos deberemos indicar en la cadena de control tantos modificadores como argumentos vayamos a presentar. El modificador est compuesto por el caracter % seguido por un caracter de conversin, que indica de que tipo de dato se trata. /* Uso de la sentencia printf() 1. */ #include <stdio.h> main() /* Saca por pantalla una suma */ { int a=20,b=10; printf("El valor de a es %d \n",a); printf("El valor de b es %d \n",b); printf("Por tanto %d+%d=%d",a,b,a+b); } Los modificadores ms utilizados son: %c %d %u %o %x %e %f %s %p Un nico caracter Un entero con signo, en base de cimal Un entero sin signo, en base decimal Un entero en base octal Un entero en base hexadecimal Un nmero real en coma flotante, con exponente Un nmero real en coma flotante, sin exponente Una cadena de caracteres Un puntero o direccin de memoria
/* Uso de la sentencia printf() 2. */ #include <stdio.h> main() /* Modificadores 1 */ { char cad[]="El valor de";
13
El formato completo de los modificadores es el siguiente: % [signo] [longitud] [.precisin] [l/L] conversin Signo: indicamos si el valor se ajustar a la izquierda, en cuyo caso utilizaremos el signo menos, o a la d erecha ( por defecto ). Longitud : especifica la longitud mxima del valor que aparece por pantalla. Si la longitud es menor que el nmero de dgitos del valor, ste aparecer ajustado a la izquierda. Precisin : indicamos el nmero mximo de dec imales que tendr el valor. l/L: utilizamos l cuando se trata de una variable de tipo long y L cuando es de tipo double. /* Uso de la sentencia printf() 3. */ #include <stdio.h> main() /* Modificadores 2 */ { char cad[ ]="El valor de"; int a=25986; long int b=1976524; float c=9.57645; printf("%s a es %9d \n",cad,a); printf("%s b es %ld \n",cad,b); printf("%s c es %.3f",cad,c); } 5.2.- Sentencia scanf( ) La rutina scanf permite entrar datos en la memoria del ordenador a travs del teclado. El prototipo de la sentencia scanf es el siguiente: scanf(control,arg1,arg2...);
En la cadena de control indicaremos, por regla general, los modificadores que harn referencia al tipo de dato de los argumentos. Al igual que en la sentencia printf los modificadores estarn formados por el caracter % seguido de un caracter de conversin. Los argumentos indicados sern, nuevamente, las variables.
14
La principal caracterstica de la sentencia scanf es que necesita saber la posicin de la memoria del ordenador en que se encuentra la variable para poder almacenar la informacin obtenida. Para indicarle esta posicin utilizaremos el smbolo ampersand ( & ), que colocaremos delante del nombre de cada variable. ( Esto no ser necesario en los arrays ).
/* Uso de la sentencia scanf(). */ #include <stdio.h> main() /* Solicita dos datos */ { char nombre[10]; int edad; printf("Introduce tu nombre: "); scanf("%s",nombre); printf("Introduce tu edad: "); scanf("%d",&edad); }
15
El resultado que devuelven estos operadores es 1 para Verdadero y 0 para Falso. Si hay ms de un operador se evalan de izquierda a derecha. Adems los operadores == y != estn por debajo del resto en cuanto al orden de precedencia.
/* Uso de los operadores relacionales. */ #include <stdio.h> main() /* Compara dos nmeros entre ellos */ { int a,b; printf("Introduce el valor de A: "); scanf("%d",&a); printf("Introduce el valor de B: "); scanf("%d",&b); if(a>b) printf("A es mayor que B"); else if(a<b) printf("B es mayor que A"); else printf("A y B son iguales");
16
7. SENTENCIAS CONDICIONALES
Este tipo de sentencias permiten variar el flujo del programa en base a unas determinadas condiciones. Existen varias estructuras diferentes: 7.1.- Estructura IF...ELSE Sintaxis: if (condicin) sentencia; La sentencia solo se ejecuta si se cumple la condicin. En caso contrario el programa sigue su curso sin ejecutar la sentencia. Otro formato: if (condicin) sentencia1; else sentencia2; Si se cumple la condicin ejecutar la sentencia1 , sin ejecutar la sentencia2 . En cualquier caso, el programa continuar a partir de la sentencia2 .
/* Uso de la sentencia condicional IF. */ #include <stdio.h> main() /* Simula una clave de acceso */ { int usuario,clave=18276; printf("Introduce tu clave: "); scanf("%d",&usuario); if(usuario==clave) printf("Acceso permitido"); else printf("Acceso denegado"); } Otro formato: if (condicin) sentencia1; else if (condicin) sentencia2; else if (condicin) sentencia3; else sentencia4; Con este formato el flujo del programa nicamente entra en una de las condiciones. Si una de ellas se cumple, se ejecuta la sentencia cor respondiente y salta hasta el final de la estructura para continuar con el programa.
17
/* Uso de la sentencia condicional ELSE...IF. */ #include <stdio.h> main() /* Escribe beb, nio o adulto */ { int edad; printf("Introduce tu edad: "); scanf("%d",&edad); if (edad<1) printf("Lo siento, te has equivocado."); else if (edad<3) printf("Eres un beb"); else if (edad<13) pri ntf("Eres un nio"); else printf("Eres adulto"); } 7.2.- Estructura SWITCH Esta estructura se suele utilizar en los mens, de manera que segn la opcin seleccionada se ejecuten una serie de sentencias. Su sintaxis es: switch (variable){ case contenido_variable1: sentencias; break; case contenido_variable2: sentencias; break; default: sentencias; } Cada case puede incluir una o ms sentencias sin necesidad de ir entre llaves, ya que se ejecutan todas hasta que se encuentra la sentencia BREAK . La variable evaluada slo puede ser de tipo entero o caracter . default ejecutar las sentencias que incluya, en caso de que la opcin escogida no exista.
/* Uso de la sentencia condicional SWITCH. */ #include <stdio.h> main() /* Escribe el da de la semana */ { int dia; printf("Introduce el da: "); scanf("%d",&dia);
18
19
8. OPERADORES LOGICOS
Los operadores lgicos bsicos son tres: && || ! AND OR NOT (El valor contrar io)
Estos operadores actan sobre expresiones lgicas. Permiten unir expresiones lgicas simples formando otras ms complejas.
V = Verdadero
F = Falso
/* Uso de los op. lgicos AND,OR,NOT. */ #include <stdio.h> main() /* Compara un nmero i ntroducido */ { int numero; printf("Introduce un nmero: "); scanf("%d",&numero); if(!(numero>=0)) printf("El nmero es negativo"); else if((numero<=100)&&(numero>=25)) printf("El nmero est entre 25 y 100"); else if((numero<25)||(numero>100)) printf("El nmero no est entre 25 y 100"); }
20
9. BUCLES
Los bucles son estructuras que permiten ejecutar partes del cdigo de forma repetida mientras se cumpla una condicin. Esta condicin puede ser simple o compuesta de o tras condiciones unidas por operadores lgicos. 9.1.- Sentencia WHILE Su sintaxis es: while (condicin) sentencia; Con esta sentencia se controla la condicin antes de entrar en el bucle. Si sta no se cumple, el programa no entrar en el buc le. Naturalmente, si en el interior del bucle hay ms de una sentencia, stas debern ir entre llaves para que se ejecuten como un bloque.
/* Uso de la sentencia WHILE. */ #include <stdio.h> main() /* Escribe los nmeros del 1 al 10 */ { int numero=1; while(numero<=10) { printf("%d\n",numero); numero++; } } 9.2.- Sentencia DO...WHILE Su sintaxis es: do{ sentencia1; sentencia2; }while (condicin); Con esta sentencia se controla la condicin al final del buc le. Si sta se cumple, el programa vuelve a ejecutar las sentencias del bucle. La nica diferencia entre las sentencias while y do...while es que con la segunda el cuerpo del bucle se ejecutar por lo menos una vez.
21
}
9.3.- Sentencia FOR Su sintaxis es: for (inicializacin;condicin;incremento){ sentencia1; sentencia2; } La inicializacin indica una variable (variable de control) que condiciona la repeticin del bucle. Si hay ms, van separadas por comas: for (a=1,b=100;a!=b;a++,b - -){ El flujo del bucle FOR transcurre de la siguiente forma:
22
int num,x,result; printf("Introduce un nmero: "); scanf("%d",&num); for (x=0;x<=10;x++){ result=num*x; printf("\n%d por %d = %d\n",num,x,result); }
}
9.4.- Sentencia BREAK Esta sentencia se utiliza para terminar la ejecucin de un bucle o salir de una sentencia SWITCH . 9.5.- Sentencia CONTINUE Se utiliza dentro de un bucle. Cuando el programa llega a una sentencia CONTINUE no ejecuta las lneas de cdigo que hay a continuacin y salta a la siguiente iteracin del bucle. Y aqu termina el captulo dedicado a los bucles. Existe otra sentencia, GOTO , que permite al programa saltar hacia un punto identificado con una etiqueta, pero el buen programador debe prescindir de su utilizacin. Es una sentencia muy mal vista en la programacin en 'C'. /* Uso de la sentencia CONTINUE. */ #include <stdio.h> main() /* Escribe d el 1 al 100 menos el 25 */ { int numero=1; while(numero<=100) { if (numero==25) { numero++; continue; } printf("%d\n",numero); numero++; }
23
10. FUNCIONES
10.1.- Tiempo de vida de los datos Segn el lugar dond e son declaradas puede haber dos tipos de variables. Globales : las variables permanecen activas durante todo el programa. Se crean al iniciarse ste y se destruyen de la memoria al finalizar. Pueden ser utilizadas en cualquier funcin. Locales : las variables son creadas cuando el programa llega a la funcin en la que estn definidas. Al finalizar la funcin desaparecen de la memoria. Si dos variables, una global y una local, tienen el mismo nombre, la local prevalecer sobre la global dent ro de la funcin en que ha sido declarada. Dos variables locales pueden tener el mismo nombre siempre que estn declaradas en funciones diferentes.
/* Variables globales y locales. */ #include <stdio.h> int num1=1; main() /* Escribe dos cifras */ { int num2=10; printf("%d\n",num1); printf("%d\n",num2);
}
10.2.- Funciones Las funciones son bloques de cdigo utilizados para dividir un programa en partes ms pequeas, cada una de las cules tendr una tarea determinada. Su sintaxis es: tipo_funcin nombre_funcin (tipo y nombre de argumentos) { bloque de sentencias } tipo_funcin : puede ser de cualquier tipo de los que conocemos. El valor devuelto por la funcin ser de este tipo. Por defecto, es decir, si no indicamos el tipo , la funcin devolver un valor de tipo entero ( int ). Si no queremos que retorne ningn valor deberemos indicar el tipo vaco ( void ). nombre_funcin: es el nombre que le daremos a la funcin.
24
tipo y nombre de argumentos: son los parmetros que recibe la funcin. Los argumentos de una funcin no son ms que variables locales que reciben un valor. Este valor se lo enviamos al hacer la llamada a la funcin. Pueden existir funciones que no reciban argumentos. bloque de sentencias: es el conjunto de sentencias que sern ejecutadas cuando se realice la llamada a la funcin. Las funciones pueden ser llamadas desde la funcin main o desde otras funciones. Nunca se debe llamar a la funcin main desde otro lugar del programa. Por ltimo recalcar que los argumentos de la funcin y sus variables locales se destruirn al finalizar la ejecucin de la misma. 10.3.- Declaracin de las funciones Al igual que las variables, las funciones tambin han de ser declaradas. Esto es lo que se conoce como prototipo de una funcin. Para que un programa en C sea compatible entre distintos compiladores es imprescindible escribir los prototipos de las funciones. Los prototipos de las funciones pueden escribirse antes de la funcin main o bin en otro fichero. En este ltimo caso se lo indicaremos al compilador mediante la directiva #include . En el ejemplo adjunto podremos ver la declaracin de una funcin ( prototipo ). Al no recibir ni retornar ningn valor, est declarada como void en ambos lados. Tambin vemos que existe una variable global llamada num. Esta variable es reconocible en todas las funciones del programa. Ya en la funcin main encontramos una variable local llamada num. Al ser una variable local, sta tendr preferencia sobre la global. Por tanto la funcin escribir los nmeros 10 y 5. /* Declaracin de funciones. */ #include <stdio.h> void funcion(void); /* prototipo */ int num=5; /* variable global */ main() /* Escribe dos nmeros */ { int num=10; /* variable local */ printf("%d\n",num); funcion(); /* llamada */ } void funcion(void) { printf("%d\n",num); } 10.4.- Paso de parmetros a una funcin Como ya hemos visto, las funciones pueden retornar un valor. Esto se hace mediante la instruccin return , que finaliza la ejecucin de la funcin, devolviendo o
25
/* Paso de parmetros. */ #include <stdio.h> int suma(int,int); /* prototipo */ main() /* Realiza una suma */ { int a=10,b=25,t; t=suma(a,b); /* guardamos el valor */ printf("%d=%d",suma(a,b),t); suma(a,b); /* el valor se pierde */ } int suma(int a,int b) { return (a+b); } Ahora veremos lo que se conoce como paso de parmetros. Existen dos formas de enviar parmetros a una funcin: Por valor: cualquier cambio que se realice dentro de la funcin en el argumento enviado, NO afectar al valor original de las variables utilizadas en la llamada. Es como si trabajaramos con una copia , no con el original . No es posible enviar por valor arrays , deberemos hacerlo por referencia. Por referencia: lo que hacemos es enviar a la funcin la direcci n de memoria donde se encuentra la variable o dato. Cualquier modificacin SI afectar a las variables utilizadas en la llamada. Trabajamos directamente con el original . /* Paso por valor. */ #include <stdio.h> void intercambio(int,int); main() /* Intercambio de valores */ { int a=1,b=2;
26
void intercambio (int x,int y) { int aux; aux=x; x=y; y=aux; printf("a=%d y b=%d",x,y);
}
Para enviar un valor por refere ncia se utiliza el smbolo & ( ampersand ) delante de la variable enviada. Esto le indica al compilador que la funcin que se ejecutar tendra que obtener la direccin de memoria en que se encuentra la variable. Vamos a fijarnos en los ejemplos. En e l ejemplo anterior podrs comprobar que antes y despus de la llamada, las variables mantienen su valor. Solamente se modifica en la funcin intercambio ( paso por valor ). En el siguiente ejemplo podrs ver como las variables intercambian su valor t ras la llamada de la funcin ( paso por referencia ). Las variables con un * son conocidas como punteros , el nico dato en 'C' que puede almacenar una direccin de memoria.
/* Paso por referencia. */ #include <stdio.h> void intercambio(int *,int * ); main() /* Intercambio de valores */ { int a=1,b=2; printf("a=%d y b=%d",a,b); intercambio(&a,&b); /* llamada */ printf("a=%d y b=%d",a,b); } void intercambio (int *x,int *y) { int aux; aux=*x; *x=*y; *y=aux; printf("a=%d y b=%d",*x,*y);
28
11. ARRAYS
Un array es un identificador que referencia un conjunto de datos del mismo tipo. Imagina un tipo de dato int; podremos crear un conjunto de datos de ese tipo y utilizar uno u otro con slo cambiar el ndice que lo referencia. El ndice ser un valor entero y positivo. En C los arrays comienzan por la posicin 0. 11.1.- Vectores Un vector es un array unidimensional , es decir, slo utiliza un ndice para referenciar a cada uno de los elementos. Su declaracin ser: tipo nombre [tamao]; El tipo puede ser cualquiera de los ya conocidos y el tamao indica el nmero de elementos del vector ( se debe indicar entre corchetes [ ] ). En el ejemplo puedes observar que la variable i es utilizada como ndice, el primer for sirve para rellenar el vector y el segundo para visualizarlo. Como ves, las posiciones van de 0 a 9 ( total 10 elementos ).
/* Declaracin de un array. */ #include <stdio.h> main() /* Rellenamos del 0 - 9 */ { int vector[10],i; for (i=0;i<10;i++) vector[i]=i; for (i=0;i<10;i++) printf(" %d",vector[i]); } Podemos inicializar (asignarle valores) un vector en el mome nto de declararlo. Si lo hacemos as no es necesario indicar el tamao. Su sintaxis es: tipo nombre []={ valor 1, valor 2...} Ejemplos: int vector[]={1,2,3,4,5,6,7,8}; char vector[]="programador"; char vector[]={'p','r','o','g','r','a','m','a ','d','o','r'}; Una particularidad con los vectores de tipo char (cadena de caracteres), es que deberemos indicar en que elemento se encuentra el fin de la cadena mediante el caracter nulo ( \0). Esto no lo controla el compilador, y tendremos que ser n osotros los que insertemos este caracter al final de la cadena. Por tanto, en un vector de 10 elementos de tipo char podremos rellenar un mximo de 9, es decir, hasta vector[8] . Si slo rellenamos los 5 primeros, hasta vector[4] , debemos asignar el c aracter nulo a vector[5] . Es muy sencillo: vector[5]='\0'; .
29
Ahora veremos un ejemplo de como se rellena un vector de tipo char. /* Vector de tipo char. */ #include <stdio.h> main() /* Rellenamos un vector char */ { char cadena[20]; int i; for (i=0;i<19 && cadena[i -1]!=13;i++) cadena[i]=getche( ); if (i==19) cadena[i]=' \0'; else cadena[i-1]='\0'; printf("\n%s",cadena); } Podemos ver que en el for se encuentran dos condiciones: 1.- Que no se hayan rellenado todos los elementos ( i<19). 2.- Que el usuario no haya pulsado la tecla ENTER, cuyo cdigo ASCII es 13. (cadena[x-i]!=13 ). Tambin podemos observar una nueva funcin llamada getche( ) , que se encuentra en conio.h . Esta funcin permite la entrada de un caracter p or teclado. Despus se encuentra un if, que comprueba si se ha rellenado todo el vector. Si es cierto, coloca el caracter nulo en el elemento n20 ( cadena[19] ). En caso contrario tenemos el else, que asigna el caracter nulo al elemento que almacen el cara cter ENTER. En resumen: al declarar una cadena deberemos reservar una posicin ms que la longitud que queremos que tenga dicha cadena. .- Llamadas a funciones con arrays Como ya se coment en el tema anterior, los arrays nicamente pued en ser enviados a una funcin por referencia. Para ello deberemos enviar la direccin de memoria del primer elemento del array. Por tanto, el argumento de la funcin deber ser un puntero. /* Envo de un array a una funcin. */ #include <stdio.h> void visualizar(int []); /* prototipo */ main() /* rellenamos y visualizamos */ { int array[25],i; for (i=0;i<25;i++) {
30
} visualizar(&array[0]);
void visualizar(int array[]) /* desarrollo */ { int i; for (i=0;i<25;i++) printf("%d",array[i]); } En el ejemplo se puede apreciar la forma de enviar un array por referencia. La funcin se poda haber declarado de otra manera, aunque funciona exactamente igual: declaracin o prototipo void visualizar(int *); desarrollo de la funcin void visualizar(int *array) 11.2.- Matrices Una matriz es un array multidimensional . Se definen igual que los vectores excepto que se requiere un ndice por cada dimensin. Su sintaxis es la siguiente: tipo nombre [tamao 1][tamao 2]...; Una matriz bidimensional se podra representar grficamente como una tabla con filas y columnas. La matriz tridimensional se utiliza, por ejemplo, para trabajos grficos con objetos 3D. En el ejemplo puedes ver como se rellena y visualiza una matriz bidimensional . Se necesitan dos bucles para cada una de las operaciones. Un bucle controla las filas y otro las columnas. /* Matriz bidimensional. */ #include <stdio.h> main() /* Rellenamos una matriz * / { int x,i,numeros[3][4]; /* rellenamos la matriz */ for (x=0;x<3;x++) for (i=0;i<4;i++) scanf("%d",&numeros[x][i]); /* visualizamos la matriz */
31
Si al declarar una matriz t ambin queremos inicializarla, habr que tener encuenta el orden en el que los valores son asignados a los elementos de la matriz. Veamos algunos ejemplos: int numeros[3][4]={1,2,3,4,5,6,7,8,9,10,11,12}; quedaran asignados de la siguiente manera : numeros[0][0]=1 numeros[0][1]=2 numeros[0][2]=3 numeros[0][3]=4 numeros[1][0]=5 numeros[1][1]=6 numeros[1][2]=7 numeros[1][3]=8 numeros[2][0]=9 numeros[2][1]=10 numeros[2][2]=11 numeros[2][3]=12 Tambin se pueden inicializar cadenas de texto: char dias[7][10]={"lunes","martes","mircoles","jueves","viernes","sbado", "domingo"}; Para referirnos a cada palabra bastara con el primer ndice: printf("%s",dias[i]);
32
12. PUNTEROS
Un puntero es una variable que cont iene la direccin de memoria de otra variable. Se utilizan para pasar informacin entre una funcin y sus puntos de llamada. 12.1.- Declaracin Su sintaxis es la siguiente: tipo *nombre; Donde nombre es, naturalmente, el nombre de la variabl e, y tipo es el tipo del elemento cuya direccin almacena el puntero. 12.2.- Operadores Existen dos operadores especiales para trabajar con punteros: & y *. El primero devuelve la direccin de memoria de su operando. Por ejemplo, si queremos guardar en el puntero x la direccin de memoria de la variable num, deberemos hacer lo siguiente: x=# El segundo devuelve el valor de la variable cuya direccin es contenida por el puntero. Este ejemplo sita el contenido de la variable apuntada por x, es decir num, en la variable a: a=*x; 12.3.- Asignacin Los punteros se asignan igual que el resto de las variables. El programa ejemplo mostrar las direcciones contenidas en p1 y p2, que ser la misma en ambos punteros. /* Asignaciones de punteros. */ #include <stdio.h> main() /* Asignamos direcciones */ { int a; int *p1,*p2; p1=&a; p2=p1; printf("%p %p",p1,p2);
33
34
13. ESTRUCTURAS
13.1.- Concepto de estructura Una estructura es un conjunto de una o ms variables, de distinto tipo, agrupadas bajo un mismo nombre para que su manejo sea ms sencillo. Su utilizacin ms habitual es para la programaci n de bases de datos, ya que estn especialmente indicadas para el trabajo con registros o fichas. La sintaxis de su declaracin es la siguiente: struct tipo_estructura { tipo_variable nombre_variable1; tipo_variable nombre_variable2; tipo_variable nombre_variable3; }; Donde tipo_estructura es el nombre del nuevo tipo de dato que hemos creado. Por ltimo, tipo_variable y nombre_variable son las variables que forman parte de la estructura. Para definir variables del tipo que acabam os de crear lo podemos hacer de varias maneras, aunque las dos ms utilizadas son stas: Una forma de definir la estructura: struct trabajador { char nombre[20]; char apellidos[40]; int edad; char puesto[10]; }; struct trabajador fijo, temp oral; Otra forma: struct trabajador { char nombre[20]; char apellidos[40]; int edad; char puesto[10]; }fijo, temporal; En el primer caso declaramos la estructura, y en el momento en que necesitamos las variables, las declaramos. En el segundo las declaramos al mismo tiempo que la estructura. El problema del segundo mtodo es que no podremos declarar ms variables de este tipo a lo largo del programa. Para poder declarar una variable de tipo
35
36
37
38
Su empleo con estructuras est especialmente indicado. Se puede hacer de varias formas: Una forma de hacerlo: struct trabajador { char nombre[20]; char apellidos[40]; int edad; }; typedef struct trabajador datos; datos fijo,temporal; Otra forma: typedef struct { char nombre[20]; char apellidos[40]; int edad; }datos; datos fijo,temporal; 13.3.- Arrays de estructuras Es posible agrupar un conjunto de elementos de tipo estructura en un array. Esto se conoce como array de estructuras :
39
Su empleo con estructuras est especialmente indicado. Se puede hacer de varias formas: Una forma de hacerlo: struct trabajador { char nombre[20]; char apellidos[40]; int edad; }; typedef struct trabajador datos; datos fijo,temporal; Otra forma: typedef struct { char nombre[20]; char apellidos[40]; int edad; }datos; datos fijo,temporal;
40
14. FICHEROS
Ahora veremos la forma de almacenar datos que podremos recuperar cuando deseemos. Estudiaremos los distintos modos en que podemos abrir un fichero, as como las funciones para leer y escr ibir en l. 14.1.- Apertura Antes de abrir un fichero necesitamos declarar un puntero de tipo FILE , con el que trabajaremos durante todo el proceso. Para abrir el fichero utilizaremos la funcin fopen( ) . Su sintaxis es: FILE *puntero; puntero = fopen ( nombre del fichero, "modo de apertura" ); donde puntero es la variable de tipo FILE , nombre del fichero es el nombre que daremos al fichero que queremos crear o abrir. Este nombre debe ir encerrado entre comillas. Tambin podemos espec ificar la ruta donde se encuentra o utilizar un array que contenga el nombre del archivo ( en este caso no se pondrn las comillas ). Algunos ejemplos: puntero=fopen("DATOS.DAT","r"); puntero=fopen("C:\\TXT\\SALUDO.TXT","w"); Un archivo puede ser abierto en dos modos diferentes, en modo texto o en modo binario. A continuacin lo veremos con ms detalle. Modo texto w w+ a a+ r r+ Modo binario wb w+b ab a+b rb r+b crea un fichero de escritura. Si ya existe lo crea de nuevo. crea un fichero de lectura y escritura. Si ya existe lo crea de nuevo. abre o crea un fichero para aadir datos al final del mismo. abre o crea un fichero para leer y aadir datos al final del mismo. abre un fichero de lectura. abre un fichero de lectura y escritura. crea un fichero de escritura. Si ya existe lo crea de nuevo. crea un fichero de lectura y escritura. Si ya existe lo cre a de nuevo. abre o crea un fichero para aadir datos al final del mismo. abre o crea un fichero para leer y aadir datos al final del mismo. abre un fichero de lectura. abre un fichero de lectura y escritura.
La funcin fopen devuelve, como ya hemos visto, un puntero de tipo FILE . Si al intentar abrir el fichero se produjese un error ( por ejemplo si no existe y lo est amos abriendo en modo lectura ), la funcin fopen devolvera NULL . Por esta razn es mejor controlar las posibles causas de error a la hora de programar. Un ejemplo:
41
FILE *pf; pf=fopen("datos.txt","r"); if (pf == NULL) printf("Error al abrir el ficher o"); freopen( ) Esta funcin cierra el fichero apuntado por el puntero y reasigna este puntero a un fichero que ser abierto. Su sintaxis es: freopen(nombre del fichero,"modo de apertura",puntero); donde nombre del fichero es el nombre del nuevo fichero que queremos abrir, luego el modo de apertura , y finalmente el puntero que va a ser reasignado. 14.2.- Cierre Una vez que hemos acabado nuestro trabajo con un fichero es recomendable cerrarlo. Los ficheros se cierran al finalizar el programa pero el nmero de estos que pueden estar abiertos es limitado. Para cerrar los ficheros utilizaremos la funcin fclose( ); . Esta funcin cierra el fichero, cuyo puntero le indicamos como parmetro. Si el fichero se cierra con xito devuelve 0. fclose(puntero); Un ejemplo ilustrativo aunque de poca utilidad: FILE *pf; pf=fopen("AGENDA.DAT","rb"); if ( pf == NULL ) printf ("Error al abrir el fichero"); else fclose(pf); 14.3.- Escritura y lectura A continuacin veremos las funciones que se podrn utilizar dependiendo del dato que queramos escribir y/o leer en el fichero. Un caracter fputc( variable_caracter , puntero_fichero ); Escribimos un caracter en un fichero ( abierto en modo escritura ). Un ejemplo: FILE *pf; char letra='a'; if (!(pf=fopen("datos.txt","w"))) /* otra forma de controlar si se produce un error */ { printf("Error al abrir el fichero"); exit(0); /* abandonamos el programa */ } else fputc(letra,pf);
42
43
Una cadena de caracteres fputs( variable_array, puntero_fichero ); Escribe una cadena de caracteres en el fichero. Ejemplo: FILE *pf; char cad="Me llamo Vicente"; if (!(pf=fopen("datos.txt","w"))) /* controlamos si se produce un error */ { printf("Error al abrir el fichero"); exit(0); /* abandonamos el programa */ } else { fputs(cad,pf); /* o tambin as: fputs("Me llamo Vicente",pf); */ fclose(pf); } fgets( variable_array, variable_entera, puntero_fichero ); Lee una cadena de caracteres del fichero y la almacena en variable_array. La variable_entera indica la longitud mxima de caracteres que puede leer. Un ejemplo: FILE *pf; char cad[80]; if (!(pf=fopen("datos.txt","rb"))) /* controlamos si se produce un error */ { printf("Error al abrir el fichero"); exit(0); /* abandonamos el programa */ } else { fgets(cad,80,pf); printf("%s",cad); fclose(pf); } Con formato fprintf( puntero_fichero, formato, argumentos); Funciona igual que un printf pero guarda la salida en un fichero. Ejemplo: FILE *pf;
44
45
Otras funciones para ficheros rewind( puntero_fichero ); Sita el puntero al principio del archivo. fseek( puntero_fichero, long posicion, int origen ); Sita el puntero en la posicion que le indiquemos. Como origen podremos poner: 0 o SEEK_SET , el principio del fichero 1 o SEEK_CUR , la posicin actual 2 o SEEK_END , el final del fichero rename( nombre1, nombre2 ); Su funcin es exactamente la misma que la que conocemos en MS-DOS. Cambia el nombre del fichero nombre1 por un nuevo nombre, nombre2 . remove( nombre ); Como la funcin del DOS del, podremos eliminar el archivo indicado en nombre . Deteccin de final de fichero feof( puntero_fichero ); Siempre deberemos controlar si hemos llegado a l final de fichero cuando estemos leyendo, de lo contrario podran producirse errores de lectura no deseados. Para este fin disponemos de la funcin feof( ) . Esta funcin retorna 0 si no ha llegado al final, y un valor diferente de 0 si lo ha alcanzado. Pues con esto llegamos al final del tema. Espero que no haya sido muy pesado. No es necesario que te aprendas todas las funciones de memoria. Cntrate sobre todo en las funciones fputs( ) , fgets( ) , fprintf( ) , fwrite( ) y fread( ) . Con estas cinco se pueden gestionar los ficheros perfectamente.
46
/* Ejemplo de una pila. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void); void extraer(void); void visualizar(void);
47
48
void visualizar(void) { if (CAB==NULL) return; AUX=CAB; while (AUX!=NULL) { printf("Nombre: %s \n",AUX->nombre); AUX=AUX->ant; } getch( ); } La estructura tipo que utilizaremos ser sta: struct pila { tipo variables; struct pila *ant; }*CAB=NULL,*AUX =NULL; donde tipo variables sern las diferentes variables que guardaremos en la estructura, struct pila *ant es un puntero que apunta al elemento de tipo pila introducido anteriormente, *CAB ser donde guardaremos el ltimo elemento insertado en la pila y *AUX nos servir para guardar elementos temporalmente y para recorrer la pila al visualizarla. Antes de insertar un elemento, deberemos comprobar si la pila est vaca o no. Si lo estuviera deberemos insertar el primer elemento: CAB=AUX; CAB->ant=NULL; Si ya hubiera algn elemento crearemos uno nuevo apuntado por AUX y haremos que AUX->ant apunte a CAB, que en este momento contiene la direccin del elemento insertado anteriormente. Tras esto haremos que CAB apunte al ltimo elemento insertado, que ser la nueva cabeza de la pila: AUX->ant=CAB; CAB=AUX; Para extraer un elemento de la pila deberemos hacer que AUX apunte a la misma direccin que CAB , despus haremos que CAB apunte a CAB->ant , con lo que el elemento anterior pas ar a ser la cabeza de la pila. Tras esto, solo queda liberar la memoria de la zona apuntada por AUX . No olvides controlar si existe algn elemento ( si CAB es igual a NULL la pila est vaca ): if (CAB==NULL) return; AUX=CAB; CAB=CAB->ant; free(AUX);
49
Por ltimo, para visualizar los elementos de la pila, haremos que el puntero auxiliar AUX apunte a la cabeza de la pila, o sea, a CAB . Tras esto iremos visualizando el contenido de la pila, haciendo que AUX tome la direccin de AUX->ant , mientras AUX sea distinto de NULL . Tambin es importante controlar que la pila no est vaca. if (CAB==NULL) return; AUX=CAB; while (AUX!=NULL) { printf("%s",AUX->nombre); AUX=AUX->ant; }; Estructura grfica de una pila:
Las colas Este tipo de estructuras se caracteriza porque insertamos los elementos por un lado y los extraemos por el otro lado. Es de tipo FIFO ( First In First Out ), el primer elemento en entrar es el primero en salir. Para gestionar la cola utilizaremos 3 punteros ( para la pila solo eran necesarios 2 ). /* Ejemplo de una cola. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void); void extraer(void); void visualizar(void); struct cola { char nombre[20];
50
51
52
AUX=CAB; /* Controlar que no est vaca: if (CAB==NULL) return; */ while(AUX!=NULL) { printf("%s",AUX->nombre); AUX=AUX->sig; } Estructura grfica de una cola:
Las listas Este tipo de estructuras se caracteriza porque los elementos estn enlazados entre s, de manera que adems de las acciones habituales de insertar, extraer y visualizar tambin podremos buscar un elemento. Para gestionar la lista utilizaremos 4 punteros. /* Ejemplo de una lista. */ #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <alloc.h> void insertar(void); void extraer(void); void visualizar(void); struct lista { int num; struct lista *sig; }*CAB=NULL,*AUX=NULL,*F=NULL,*P=NULL; main() /* Rellenar, extraer y visualizar */ { char opc;
53
printf("1.- Insertar"); printf("2.- Extraer"); printf("3.- Visualizar la lista"); printf("4.- Salir"); opc=getch( ); switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4');
/* A continuacin insertaremos el elemento que vamos a crear en la posicin que le corresponda, teniendo en cuenta que la lista deber quedar ordenada de menor a mayor. El puntero P comprueba si el campo num de un elemento es menor que el campo num del element o introducido. El puntero F se quedar apuntando al elemento de la posicin anterior al elemento que hemos insertado */ void insertar(void) { AUX=(struct lista *)malloc(sizeof(struct lista)); printf("Introduce un nmero: "); scanf("%d",&AUX ->num); AUX->sig=NULL; if (CAB==NULL) CAB=AUX; else if (CAB->num > AUX->num) { AUX->sig=CAB; CAB=AUX; } else { P=F=CAB; while (P->num < AUX->num && P!=NULL) { if (P==CAB) P=P->sig; else { P=P->sig; F=F->sig; } } AUX->sig=F->sig; F->sig=AUX;
54
void extraer(void) { int var; if (CAB==NULL) return; printf("Introduce el nmero a extraer: "); scanf("%d",&var); if (CAB->num==var) { P=CAB; CAB=CAB->sig; free(P); } else { P=F=CAB; while (P->num != var && P!=NUL L) { if (P==CAB) P=P->sig; else { P=P->sig; F=F->sig; } } if (P==NULL) return; F->sig=P->sig; free(P); } } void visualizar(void) { if (CAB==NULL) return; AUX=CAB; while (AUX!=NULL) { printf("Nmero: %d \n",AUX->num); AUX=AUX->sig; } getch( ); } La estructura que utilizaremos ser: struct lista { tipo variables; struct lista *sig; }*CAB=NULL,*AUX=NULL,*F=NULL,*P=NULL;
55
donde tipo variables sern las variables que guardaremos en la estructura, struct lista *sig es un puntero que apunta al elemento de tipo lista introducido a continuacin, *CAB ser donde guardaremos el primer elemento de la lista, *AUX nos servir para guardar elementos temporalmente y para recorrer la lista al visualizarla, *P para comparar los valores introducidos y ordenarlos, y *F, que apuntar al elemento anterior al ltimo introducido. Antes de insertar un elemento, deberemos comprobar si la lista est vaca o no. Si lo est deberemos insertar el primer elemento: if (CAB==NULL) CAB=AUX; Si ya existiera algn elemento haremos que P y F apunten al primero de la lista. Si el elemento introducido fuera menor que el primero de la lista, haramos que el nuevo elemento pasara a ser el primero, y el que hasta ahora era e l primero, pasara a ser el segundo. if (AUX->num < CAB->num){ AUX->sig=CAB; CAB=AUX; } Para extraer un elemento de la lista solicitaremos un nmero, si el nmero introducido se corresponde con el campo num de uno de los elementos, ste ser extrado de la lista. Deberemos controlar que la lista no est vaca y que el elemento con el nmero solicitado exista. Fjate en el ejemplo, en la funcin extraer. Si CAB es igual a NULL , ser que la lista est vaca, y si P es igual a NULL al salir del while significar que no se ha encontrado ningn elemento que contenga el nmero introducido. Para visualizar la lista comprobaremos que existan elementos, es decir, que CAB sea distinto de NULL . Hecho esto asignaremos a AUX la direccin de CAB e iremos recorriendo la lista mientras AUX sea distinto de NULL . if (CAB==NULL) return; AUX=CAB; while(AUX!=NULL) { printf("%d",AUX->num); AUX=AUX->sig; } Estructura grfica de una lista:
56
Aqu finaliza el tema de la gestin dinmica d e memoria. Es un tema algo complejo hasta que se asimila el concepto y funcionamiento de las diferentes estructuras, pero tras conseguirlo ya no tiene ningn secreto. Si alguna vez no recuerdas su funcionamiento siempre es una buena solucin coger papel y lpiz, dibujar una pila, cola o lista grficamente y simular la introduccin de elementos, escribiendo la situacin de los punteros en cada momento. Existen otras estructuras, como las listas doblemente enlazadas . La nica diferencia con la lista que conocemos es que en las primeras cada elemento guarda la direccin del anterior y del posterior. Sera una estructura como esta: struct lista_doble { char nombre[20]; struct lista_doble *ant; struct lista_doble *sig; }; Su funcionamiento es m uy similar al de una lista normal. Puedes intentar hacerla tu mismo.
57
58
/*Metodo de Ordenacion por Insercion*/ #include <stdio.h> #include <conio.h> #define N 100/*Elementos maximos en el arreglo*/ main () { int a[N];/*declaracion del arreglo*/ int i, n, p, u; int k, j, c, aux; printf("Total de elementos del vector :"); scanf("%d", &n);/*Total de elementos en el arreglo*/ printf ("Valores del vector : \n"); for (i=1; i<=n; i++) scanf("%d", &a[i]);/*lectura y almacenamiento de los elementos en el arreglo*/ aux=0;/*variable auxiliar para copiar los elementos*/ c=0;/*nueva posicion en el arreglo*/ for (k=2; k<=n; k++){ aux=a[k];/*copia el elemento de la posicion k del arreglo a una variable auxiliar*/ p=1;/*posicion a partir del cual empezara a comparar los elementos*/ u=k-1;/*posicion en el arreglo*/ while (p<=u){/*compara las posiciones*/ c=(p+u)/2;/*obtiene la nueva posicion del arreglo para comparar*/ if (aux < a[c])/*compara e l contenido del arreglo en la nueva posicion y el valor de la variable auxiliar(elemento)*/ u=c-1;/*decrementa la posicion del arreglo*/ else p=c+1;/*incrementa la posicion del arreglo en uno*/ } for (j=k-1 ;j>=p; j--)/*busca la posicion del elemento a cambiar*/ a[j+1]=a[j];/*cambia el elemento en el arreglo que esta contenido en aux por el nuevo elemento*/ a[p] = aux;/*cambia el elemento conteni do en la posicion p del arreglo por el elemento contenido en aux y empieza a orde nar el arreglo*/ } printf ("\n El vector ordenado es: \n"); for (i = 1; i<=n; i++) printf("%d ", a[i]);/*impresion del arreglo ordenado/ getch(); return 0;
59
/*Metodo de Ordenacion por Seleccion*/ #include "stdio.h" #include "conio.h" #define N 100 /*Maximo de elementos*/ main() { int a[N];/*Declaracion del arreglo*/ int i, j, k, menor, n; printf("Introduzca el tamao del vector \n \n"); scanf("%d", &n);/*Total de elemetos en el arreglo*/ printf("\n Introduce los elementos \n"); for (i=0; i<n; i++) scanf("%d", &a[i]);/*Lee y almacene los elementos en el arreglo*/ for (i=0; i<n-1; i++) { menor=a[i];/*obtiene el elemento en la posicion actual a i*/ k=i;/*k toma la posicion i*/ for (j=i+1; j<n; j++){/*empieza a recorrer el arreglo una posicion adelante a la de i*/ if (a[j] < menor){/*si el elemento en la posicion j del arreglo es menor que el elemento contenido en menor*/ menor=a[j]; /*menor toma el elemento contenido en j*/ k=j;/*k toma la posicion j*/ } } a[k]=a[i];/*almacena en la posicion k del arreglo el elemento contenido en la posicion i del arreglo*/ a[i]=menor;/*almacena el elemento contenido en menor en el arreglo en la posicion i*/ } printf("\t El vector ordenado es \n"); for (i=0; i<n; i++) printf("%d ", a[i]);/*imprime el arreglo ordenado*/ getch(); } return 0;
60
/*Metodo de Ordenacion por Shell*/ #include <stdio.h> #include <conio.h> #define N 100/*Maximo de elementos*/ main() { int a[N];/*declaracion del arreglo*/ int i, j, k, aux, inc, n; printf("Introduzca el tamao del vector \n \n"); scanf("%d", &n);/*tamao del arreglo*/ printf("\n Introduce los elementos \n"); for (i=1; i<=n; i++) scanf("%d", &a[i]);/*lee y almacena los elementos en el arreglo*/ inc=n/2;/*obtiene el valor de incremento para empezar a ordenar*/ while (inc>0) { for (i=inc+1; i<=n; i++) { j=i-inc;/*obtiene la posicion inicial del arreglo*/ while (j>0){ if (a[j] > a[j+inc]){/*obtiene el mayor de los elementos*/ aux=a[j];/*alamacena en la variable auxiliar aux el elemento mayor*/ a[j]=a[j+inc];/*copia el elemento menor a la posiscion en donde se encontraba el elemento mayor*/ a[j+inc]=aux;/*copia elemento mayor contenido en aux a la posicion del arreglo en donde se encontraba el elemento menor*/ j=j-inc;/*decrementa la posicion del arreglo*/ } else j=0; } } inc=inc/2;/*obtiene el valor de incrementos par a empezar a ordenar*/ } printf("\t El vector ordenado es \n"); for (i=1; i<=n; i++) printf("%d ", a[i]);/*Imprime el arreglo ordenado*/ getch(); return 0;
61
#include <stdio.h> #include <conio.h> #define N 100/*maximo de elementos*/ #define M 50 /*mitad de elementos que N*/ main(){ int mayor[M]={0}, /*arreglo auxiliar*/ menor[M]={0}, /*arreglo auxiliar*/ a[N]={0};/*arreglo principal*/ int aux, /*variable auxiliar para intercambio de elem entos*/ n, /*tamao del arreglo*/ ban; int der, /*posicion a la derecha*/ izq, /*posicion a la izquierda*/ top; /*tope del arreglo*/ int ini, /*posicion inicio*/ fin, /*posicion final*/ pos, /*posicion*/ i; printf("Introduzca el tamao del vector \n \n"); scanf("%d", &n);/*lee el tamao del arreglo*/ printf("valores para el vector: \n \n"); for (i=1; i<=n; i++) scanf("%d", &a[i]);/*lee y almacena los elementos en el arreglo principal*/ top=1; /*inicio del tope del arreglo*/ menor[top]=1; /*almacena el valor 1 en la posicion top del arreglo menor*/ mayor[top]=n; /*almacena el valor de n(tamao del arreglo) en la posicion top del arreglo mayor*/ while (top > 0) {/*Mientras la posicion top s ea mayor que 0*/ ini=menor[top];/*ini toma el elemento contenido en la posicion top del arreglo menor*/ fin=mayor[top];/*fin toma el elemento contenido en la posicion top del arreglo mayor*/ top--;/*decrementa la posicion top menos uno*/ izq=ini;/*izq toma el valor de ini*/ der=fin;/*der toma el valor de fin*/ pos=ini;/*pos toma el valor de ini*/ ban=1;/*variable de desicion a ordenar toma el valor 1*/ while (ban){/*mientras ban valga 1*/ while ((a[pos]<=a[der]) && (pos!=der))/*di sminuye el valor de der si el valor del elemento en a[pos] es menor*/ der--; /*que a[der] y ademas pos es diferente que der*/
62
63
64
#include <stdio.h> #include <conio.h> #include <string.h> int valores(char let); main(){ char cad[10]={"\0"}; /*almacenara el numero romano*/ /*cadenas que almacenaran las divisiones de todo el num ero*/ char millar[4]={"\0"}; char centenas[4]={"\0"}; char decenas[4]={"\0"}; char unidades[4]={"\0"}; /*variables para el cambio entre cada valor*/ int ban1=1, ban2=0, ban3=0, ban4=0; int tam,/*tamao de la cadena*/ i,j,/*indices para accesar a las c adenas*/ acum,/*resultado de una conversion de romanos a decimal*/ valor,/*valor decimal de un numero romano*/ acumgral;/*numero romano en decimal*/ clrscr(); printf("Introduce un numero en romanos : "); gets(cad);/*lectura del numero roman o*/ tam=strlen(cad);/*determina el tamao de la cadena del numero romano*/ /*proceso para dividir un numero romano en sus diferentes fracciones*/ j=0; for(i=0; i<tam; i++){/*recorrera todo el contenido de la cadena que contiene el numero romano*/ /*obtiene los millares, siempre y cuando cumpla con las condiciones*/ if (cad[i]=='M' && ban1)/*ban1 significa que se va evaluar el primer if*/ millar[j++]=cad[i];/*almacena en la cadena de millares los valores*/ else{ if (ban1){ ban1=0;/*cuando de un valor 1 pasa a un valor 0 indica que ya no volvera a entrar de nuevo a este if*/ ban2=1;/*activa el siguiente if*/ millar[j]='\0';/*finaliza la cadena de millares*/ j=0;/*inicia el indice para la siguiente lectura y es critura de las centenas*/ } }
65
/*obtiene las centenas, es el mismo proceso que el anterior*/ if ((cad[i]=='C' || cad[i]=='D' || cad[i]=='M') && ban2) centenas[j++]=cad[i]; else{ if (ban2){ ban2=0; ban3=1; centenas[j]='\0'; j=0; } } /*obtiene las decenas el proceso es igual que el anterior*/ if ((cad[i]=='X' || cad[i]=='L' || cad[i]=='C') && ban3) decenas[j++]=cad[i]; else{ if (ban3){ ban3=0; ban4=1; decenas[j]='\0'; j=0; } } /*obtiene las unidades, porceso igual que el anterior*/ if (ban4) unidades[j++]=cad[i]; else{ if (ban4){ ban4=0; unidades[j]='\0'; } }
acumgral=0;/*se almacenara el resultado en decimal*/ /*obtener millares*/ tam=strlen(millar);/*se determina el tamao de la cadena de millares*/ acum=0;/*acumulador para obtener los millares en decimal, este sera reutilizado para cada uno de los calculos diferentes*/ for(i=0; i<tam; i++){/*recorrerar la cadena buscando valores de millar*/ valor=valores(millar[i]);/*se obtiene el valor del romano en decimal, este valor es en millares*/ acum+=valor;/*se suma el valor obtenido al acumulador, para ver cuto es en miles*/ } acumgral+=acum;/*se suma al acumulador general el valor obtenido en miles*/
66
/*obtener centenas*/ /*el proceso es parecido en cuestion de las sumas y calcular tamao de la cadena*/ tam=strlen(centenas); acum=0; acum=valores(centenas[0]);/*se obtiene un primer valor para verificar despues si este es mayor que el nuevo valor obtenido, este se almacena en el acumulador*/ for(i=1; i<=tam; i++){ valor=valores(centenas[i]);/*se obtiene el valor en decimal y verifica el tamao*/ if (valor<=acum)/*numeros >=100 y <=300 o >500 y <=800*/ acum+=valor; else/*si el valor obtenido es mayor que el valor que ya se tenia entonces se trara de un numero >300 y <500 o >800 y <1000 */ acum=valor-acum; } acumgral+=acum; /*obtener decenas*/ /*el proceso es el mismo que el de centenas*/ tam=strlen(decenas); acum=0; acum=valores(decenas[0]); for(i=1; i<=tam; i++){ valor=valores(decenas[i]); if (valor<=acum)/*numeros >=10 y <=30 o >50 y <=80*/ acum+=valor; else/*numeros >30 y <50 o >80 y <100 */ acum=valor-acum; } acumgral+=acum; /*obtener unidades*/ /*el proceso es el mismo que para las decenas*/ tam=strlen(unidades); acum=0; acum=valores(unidades[0]); for(i=1; i<=tam; i++){ valor=valores(unidades[i]); if (valor<=acum)/*numeros >=1 y <=3 o >5 y <=8*/ acum+=valor; else/*numeros >3 y <5 o >8 y <10 */ acum=valor-acum; } acumgral+=acum; printf("El valor en decimal es : %d", acumgral); getch(); return 0; }
67
int valores(char let) { switch (let){ case 'I':return 1; case 'V':return 5; case 'X':return 10; case 'L':return 50; case 'C':return 100; case 'D':return 500; case 'M':return 1000; } return 0; }
68
#include <stdio.h> #include <conio.h> #define N 3 void insertar(int [N], int*, int); int sacar(int [N], int*, int*); void imprimir(int [N], int, int); main() { int frente=-1, final=0; int cola[N]={0}, num, op; do{ printf("\t\tOperaciones de la colas \n"); printf("\t\t\tInsertar....1\n"); printf("\t\t\tSacar.......2\n"); printf("\t\t\tImprimir....3\n"); printf("\t\t\tSalir.......4\n"); printf("\t\t\tOpcion...."); scanf("%d", &op); switch(op){ case 1: printf("\n\tElemento a insertar :"); scanf("%d", &num); insertar(cola, &frente, num); break; case 2: num=sacar(cola, &frente, &final); if (num == -9999){ printf("\n\n\tCola Vacia"); frente=-1; final=0; } else printf("\n\tElemento sacado : %d", num); getch(); break; case 3: imprimir(cola, frente, final); getch(); break; } }while(op!=4); getch(); return 0; } void insertar(int cola[N], int *frente, int numero) { if (*frente > N) printf("\n\n\tCola llena");
69
(*frente)++; cola[*frente]=numero;
int sacar(int cola[N], int *frente, int *final) { int num; if (*final > *frente) return -9999; else{ num=cola[*final]; (*final)++; return num; } } void imprimir(int cola[N], int frente, int final) { if (final > frente) printf("\n\n\tCola vacia"); else{ printf("\nElemetos en la Cola : \n"); for (final=final; final<=frente; fi nal++) printf("\t\t\t%d\n",cola[final]); } }
70
#include <stdio.h> #include <stdlib.h> #include <conio.h> //registro para la creacin de los nodos del arbol struct nodos{ int dato; //dato que se almacenara en el nodo, este dato puede ser de cualquier tipo, incluso un registro struct nodos *der; //generacion de las ramas del arbol hacia la derecha struct nodos *izq; //generacion de las ramas del arbol hacia la izquierda }; typedef struct nodos Arbol; typedef Arbol *ARBOL; //funciones para la impresion de los nodos del arbol void inorden(ARBOL); void preorden(ARBOL); void postorden(ARBOL); //funcion para crear un nodo en el arbol void insertar(ARBOL*, int); main(){ int op,ele; ARBOL raiz=NULL;//raiz , es el inicio del arbol do{ printf("\t Operaciones del Arbol \n"); printf("\t1..Insertar\n"); printf("\t2..Imprimir inorden\n"); printf("\t3..Imprimir preorden \n"); printf("\t4..Imprimir postorden \n"); printf("\t5..Salir\n"); printf("\n\tElija opcion ...");scanf("%d", &op); switch(op){ case 1:printf("\n\n\tIntroduce el elemento : "); scanf("%d", &ele); //lectura del elemento o dato a almacenar en el arbol insertar(&raiz,ele); //se envia a la funcion la direccion del inicio del ar bol y el elemento a insertar break; case 2:printf("\n\n\tLa impresion inorden es : \n"); inorden(raiz);//impresion de los elementos del arbol getch(); break;
71
void insertar(ARBOL *nodoarb, int valor) { if (*nodoarb == NULL){ //Pregunta si hay algun nodo en el arbol, si no lo hay lo crea, pero si existe debe v //verificar hacia que lado del arbol lo almacenara, recuerda que es balanceado *nodoarb = new(Arbol); if (*nodoarb != NULL){ //se crea el nuevo nodo del arbol y se almacenaran los datos (*nodoarb)->dato=valor; //almacena el elemento que se envio (*nodoarb)->der=NULL; (*nodoarb)->izq=NULL; } else printf("\n\tNo hay memoria suficiente \n"); } else if (valor < (*nodoarb) ->dato) //si el valor a almacenar es menor que el valor del dato colocado en la raiz insertar (&((*nodoarb) ->izq), valor); //lo inserta a la izquierda else if (valor > (*nodoarb) ->dato) //si es mayor insertar (&((*nodoarb)->der), valor); //lo almacena a la derecha else printf("\n\tDato duplicado\n"); //no se pueden duplicar los datos } void inorden(ARBOL nodoarb) { // impresion en forma ordenada, este ira a buscar el valor mas a la izquierda, una vez que // se encontro el valor mas a la izquierda regresa al nodo superior a el y este se va a la // derecha para ver si hay elementos que imprimir, si los hay se imprime, de lo contrario // este imprime el nodo en donde se encuentra, convirtiendose, este nodo en el nodo mas
72
73
INDICE
Caracteristicas del Lenguaje C Estructura de un programa Tipos de Datos Operadores Aritmeticos y de asignacin Salida y Entrada Operadores Relacionales Sentencias Condicionales Operadores Logicos Bucles Funciones Arrays Punteros Estructuras Ficheros Gestion Dinamica de Memoria Programas de Aplicacin
1 3 5 10 13 16 17 21 22 25 30 34 36 42 48 57 75
Indice
74