TRABAJO DE PROGRAMACION

Nombre: Marco Silva Curso: cuarto comun Fecha: 12-04-2012

Investigar todo lo referente a Lenguaje C++ Antecedentes Histricos C++ es un nuevo lenguaje de programacin que est construido sobre un viejo lenguaje: el lenguaje de programacin C. El lenguaje C fue desarrollado a principios de los 1970 en los Laboratorios Bell, construido originalmente como una herramienta dentro de un sistema de programacin (sistemas operativos por ejemplo) as como para el desarrollado de compiladores. No era necesario indicar el lenguaje del usuario final, es decir, que era un lenguaje para propsito general. Sin embargo, C se volvi extremadamente exitoso y es ahora ampliamente usado en la industria y la academia. Dennis Ritchie fue el primero en desarrollar un lenguaje C, el cual corra sobre una computadora DEC PDP-11. El desarrollo de C se baso en otro viejo lenguaje llamado B que a su vez tiene su origen en otro lenguaje an ms antiguo denominado BCPL. Sin embargo fue hasta 1978 cuando Brian Kernoghan y Ritchie Publicaron una descripcin final de dicho lenguaje, esta descripcin comn mente denominada K&R C, contena las caractersticas deseas del lenguaje. A mediados de 1980 el lenguaje tena una popularidad extendida por todas partes, da a da se escriban, nuevos interpretes y compiladores para dicho lenguaje, inclusive programas escritos en otros lenguajes se rescribieron en C. C era un lenguaje que ofreca a los programadores eficiencia y potencia en su trabajo, fue esto lo que hara que dicho lenguaje, ganara gran parte de su fama, este lenguaje fue clasificado por la comunidad informtica como lenguaje de Medio Nivel, por que sus capacidades, lo hacan superior de otros lenguajes, tales como Pascal de Borland, Cobol, etc. Qu es Lenguaje C++? Como todos sabemos, "C" es un lenguaje de alto nivel, basado en funciones, que permite desarrollos estructurados. Entre otras muchas caractersticas contempla la definicin de estructuras de datos, recursividad o indirecciones a datos o cdigo (punteros). "C ++", por su parte, es un superconjunto de "C", al que recubre con una capa de soporte a la POO. Permite por tanto la definicin, creacin y manipulacin de objetos. El lenguaje C++ se conoce como un lenguaje compilado. Existen dos tipos de lenguaje: interpretados y compilados. Los interpretados son aquellos que necesitan del cdigo fuente para funcionar (P.ej: Basic). Los compilados convierten el cdigo fuente en un fichero objeto y ste en un fichero ejecutable. Este es el caso del lenguaje C++. Palabras reservadas

Las 32 palabras reservadas de C se escriben todas en letras minsculas, de acuerdo con el Comit de normalizacin internacional ANSI C, dichas palabras son:
auto break case char const double else enum extern float int long register return short signed sizeof static struct switch typedef union unsigned void volatile while

continue for default do goto if

Adicionalmente, algunos compiladores de C han agregado algunas palabras reservadas para explotar mejor su sistema operativo. Por ejemplo, varios compiladores incluyen palabras clave para manejar la organizacin de la memoria de la familia de procesadores 8086, soportar programacin entre-lenguajes y acceso a interrupciones. La siguiente es una lista de esas palabras claves:
asm interrupt _ss _cs cdecl near _ds far pascal huge

Qu necesito para correr C++?. Las caractersticas necesarias para poder correr un Programa en Lenguaje C++ son:

Un computador IBM PC AT o compatible. MS-DOS 3.31 o una versin posterior. Un ratn compatible con Microsoft. Monitor EGA, VGA o mayor resolucin. Por lo menos 8 Mbytes libres en disco duro.

Caractersticas de Lenguaje C++ 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 permite crear procedimientos en bloques dentro de otros procedimientos. Hay que destacar que el C++ es un lenguaje estndar, ya que permite utilizar

el mismo cdigo en diferentes equipos y sistemas informticos: el lenguaje es independiente de la arquitectura de cualquier mquina en particular. El C++ se lo pude calificar como lenguaje relativamente pequeo; se puede describir en poco espacio y aprender rpidamente. Adems se puede decir que:

C++ es fuertemente tipeado: Es decir que cada objeto debe pertenecer a un cierto tipo y que cada operacin tal como la asignacin o la comparacin son solamente permitidas entre objetos del mismo tipo. Dado que las funciones requieren entradas de un cierto tipo no aceptarn entradas de otro tipo. Sin embargo, esto no es totalmente cierto en un sentido estricto ya que hay algunas reglas que permiten conversiones entre tipos (por ejemplo, un entero puede temporalmente ser cambiado temporalmente a un nmero real para realizara alguna operacin determinada). C++ proporciona el concepto de clase: Un tipo de registro que combina datos y las funciones que operan sobre ellos. Con C++ es posible sobrecargar operadores con clases definidas por el usuario. Por ejemplo una clase definida por el usuario podra ser una de nmeros racionales que pudiera implementar la operacin de adicin ordinaria usando el operador +. Como consecuencia, estas clases pueden comportarse mas como tipos que incorporan tipos. C++ soporta tipos parametrizados o templates. Las funciones templates pueden trabajar sobre diferentes tipos de entradas. Por ejemplo, es posible escribir una simple funcin swap que trabaje sobre todos los tipos posibles. Sin embargo, las dos variables sern verificadas para asegurar la correspondencia entre sus tipos. Con los templates es posible definir que una clase de arreglos que trabaje en forma booleana, caracteres, enteros, reales, entre otros. C++ soporta herencia, un mecanismo que hace posible la construccin de nuevas clases (llamadas clases derivadas) sobre las clases existentes (llamadas las clases base) sin tener que repetir el cdigo de la clase base para cada nueva clase. Herencia es un gran avance para la reutilizacin de cdigo. C++ soporta polimorfismo an cuando es fuertemente tipeado: Una variable de apuntadores del tipo de la clase base puede dinmicamente asumir el tipo de la clase derivada. Junto con la herencia, esto vuelve a C++ un lenguaje orientado a objetos completamente maduro. C++ viene con dos libreras Estndar Library y Estndar Template Library (STL): Cada una de estas libreras extiende las capacidades del lenguaje base:
o

La Standard Library proporciona todas las viejas libreras de C as como tambin las facilidades de entrada y salida. o La STL proporciona una librera de tipos de contenedores (tipos que mantienen o "contienen" colecciones de objetos) as como tambin un conjunto de algoritmos de propsitos generales para estructuras de datos comunes que se denominan algoritmos tipo "attendant". Es decir, los suplementos de STL son tipos empotrados de C++ con vectores, listas ligadas, rboles balanceados y otros tipos tiles. C++ permite variables de referencia, lo que hace posible llamadas por referencia, el compilador mejora mucho el costo de la asignacin de memoria, ya que permite a este accesos de solo lectura a na rea de almacenamiento particular

Construccin de una aplicacin bsica Seguiremos los siguientes pasos: Crear un nuevo proyecto. Desde el men "Fichero", en la opcin "Nuevo". Seleccionar objetivo del proyecto. Seleccionaremos "aplicacin basada en MFC" Nombrar el proyecto. Visual C++ organiza los proyectos de manera que crea un subdirectorio nuevo con el nombre de cada proyecto. Aunque esta "regla" siempre puede modificarse, puede ser una buena forma de control de proyectos. En estos momentos aparecer la secuencia de dilogos del generador ClassWizard. Veamos cuales seran los pasos a seguir para crear una aplicacin sencilla: Paso 1. Permite identificar el modelo de ventana principal de nuestra aplicacin: SDI, MDI o basada en dilogo. Nosotros elegiremos SDI. Paso 2. Permite incorporar soporte a Bases de Datos en la aplicacin. Esto lo veremos ms adelante. Seleccionaremos la opcin sin soporte a bases de datos. Paso 3. Relativo al soporte OLE. Igual que en el caso anterior. Paso 4. Otras caractersticas de la aplicacin (barra de botones, barra de estado, controles 3D ) Paso 5. Generacin de comentarios en el cdigo (si/no) y usos posibles de las MFC (como DLL o como LIB). Se recomienda la opcin DLL en cuanto al tamao y modularidad del programa, pero deberemos asegurarnos de distribuir la DLL junto con nuestro programa para que funcione correctamente. Paso 6. Permite modificar el nombre de las clases MFC que se van a generar, adems de especificar los ficheros en los que se implementa y la clase base de la que derivan. Los nombres generados por AppWizard suelen ser bastantes significativos. A partir de este momento da comienzo la generacin del cdigo definido antes. Como se habr observado, el nombre por defecto de las clases generadas tiene mucho que ver con el nombre que le hayamos dado al proyecto. De esta manera, si hubisemos llamado "curso1" al proyecto tendramos la siguiente situacin: Clase CCurso1App (mdulos curso1.h y curso1.cpp) que representa una aplicacin Windows. Clase CMainFrame (ficheros mainfrm.h y mainfrm.cpp) que representan la ventana principal de la aplicacin. Clases CCurso1Doc y CCurso1View (ficheros curso1doc.h/curso1doc.cpp y curso1view.h/curso1view.cpp respectivamente), representantes de lo que se conoce en el mundo Windows como interfaz "Documento/Vista" y que trataremos en adelante. Clase CAboutDlg que representa el tpico dilogo de "Acerca de " y que ha sido generado automticamente por AppWizard, esta clase (rompiendo la norma habitual de la MFC) aparece definida e implementada dentro los mismos ficheros que la clase aplicacin (mdulos curso1.h y curso1.cpp). En el futuro evitaremos este tipo de construcciones. Estructura de un Programa en Lenguaje C++

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 }

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 comentario */ /* 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.

Identificadores.- Un identificador es el nombre que damos a las variables y funciones. Est formado por una secuencia de letras y dgitos, aunque tambin acepta el carcter de subrayado _. Por contra no acepta los acentos ni la /.

El primer carcter 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, as num, Num y nuM son distintos identificadores. A continuacin vemos algunos ejemplos de identificadores vlidos y no vlidos: <> Vlidos No vlidos

<> _num 1num var1 nmero2 fecha_nac ao_nac

Tipos de Datos<>

Tipos

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 Tamao Rango de valores <> char 1 byte -128 a 127 int 2 bytes -32768 a 32767 float 4 bytes 3'4 E-38 a 3'4 E+38 double 8 bytes 1'7 E-308 a 1'7 E+308

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.

Tamao rango de valores signed char 1 byte -128 a 127 signed int 2 bytes -32768 a 32767

unsigned.- Le indica a la variable que no va a llevar signo (valor absoluto). Tamao rango de valores

unsigned char 1 byte 0 a 255 unsigned int 2 bytes 0 a 65535

short.- Rango de valores en formato corto (limitado). Es el utilizado por defecto. Tamao rango de valores

o o

short char<> 1 byte -128 a 127 short int<> 2 bytes -32768 a 32767 long.- Rango de valores en formato largo (ampliado).

Tamao rango de valores

Long int 4 bytes -2.147.483.648 a 2.147.483.647 Long double<> 10 bytes -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 4 bytes 0 a 4.294.967.295 (El mayor entero permitido en 'C') 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>=<valor>,<nombre3>=<valor>,<nombre4> Ejemplo: /* Uso de las variables */ #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); } Declaracin de variables Las variables pueden ser de dos tipos segn el lugar en que las declaremos: globales o 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 carcter 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); } Constantes Al contrario que las variables, las constantes mantienen su valor a lo largo de todo 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, sino 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 main() /* Calcula el permetro */ { int r; escribe("Introduce el radio: "); scanf("%d",&r); escribe("El permetro es: %f",2*pi*r); }

Secuencias de escape Ciertos caracteres no representados grficamente se pueden representar mediante lo que se conoce como secuencia de escape. A continuacin vemos una tabla de las ms significativas: <> \n<> salto de lnea <>\b<> retroceso <>\t<> tabulacin horizontal <>\v<> tabulacin vertical <>\\<> contrabarra <>\f<> salto de pgina <>\'<> apstrofe <>\"<> comillas dobles <>\0<> fin de una cadena de caracteres /* 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"); } Inclusin de ficheros En la programacin en C es posible utilizar funciones que no estn incluidas en el propio programa. Para ello utilizamos la directiva #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> Operadores aritmticos y de asignacin<>

A continuacin se explican los tipos de operadores (aritmticos y de asignacin) que permiten realizar operaciones matemticas en lenguaje C. Operadores aritmticos Existen dos tipos de operadores aritmticos: Los binarios: <> +<> Suma -<> Resta *<> Multiplicacin /<> Divisin %<> Mdulo (resto) Los unarios: <> ++<> Incremento (suma 1) - -<> Decremento (resta 1) -<> Cambio de signo Su sintaxis es: <> binarios: <variable1><operador><variable2> <> unarios: <variable><operador> y al revs, <operador><variable>. /* 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); <> } Operadores de asignacin La mayora de los operadores aritmticos binarios explicados en el captulo anterior tienen su correspondiente operador de asignacin: <> =<> Asignacin simple +=<> Suma -=<> Resta *=<> Multiplicacin /=<> Divisin %=<> Mdulo (resto) 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); <> } Jerarqua de los operadores

Ser importante tener en cuenta la 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 encontramos 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 <> 1. a*b resultado = x 2. c/d resultado = y 3. x+y resultado = z 4. z-e 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); } Salida / Entrada 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 argumentos 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<> Un nico carcter %d<> Un entero con signo, en base decimal %u<> Un entero sin signo, en base decimal %o<> Un entero en base octal %x<> Un entero en base hexadecimal %e<> Un nmero real en coma flotante, con exponente %f<> Un nmero real en coma flotante, sin exponente %s<> Una cadena de caracteres %p<> Un puntero o direccin de memoria /* Uso de la sentencia printf() 2. */ #include <stdio.h> main() /* Modificadores 1 */ { char cad[]="El valor de"; int a=-15;

unsigned int b=3; float c=932.5; printf("%s a es %d\n",cad,a); printf("%s b es %u\n",cad,b); printf("%s c es %e o %f",cad,c,c); } 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 derecha ( 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 decimales 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); <> } 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 carcter % seguido de un carcter de conversin. Los argumentos indicados

sern, nuevamente, las variables. 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); } Operadores Relacinales Los operadores relacionales se utilizan para comparar el contenido de dos variables. En C++ existen seis operadores relacionales bsicos: <> ><> Mayor que <<> Menor que >=<> Mayor o igual que <=<> Menor o igual que ==<> Igual que !=<> Distinto que 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"); }

Sentencia Condicionales<> Este tipo de sentencias permiten variar el flujo del programa en base a unas determinadas condiciones. Existen varias estructuras diferentes: 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 correspondiente y salta hasta el final de la estructura para continuar con el programa. Existe la posibilidad de utilizar llaves para ejecutar ms de una sentencia dentro de la misma condicin. /* 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) printf("Eres un nio"); else printf("Eres adulto"); } 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 carcter. 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); switch(dia){ case 1: printf("Lunes"); break; case 2: printf("Martes"); break; case 3: printf("Mircoles"); break; case 4: printf("Jueves"); break; case 5: printf("Viernes"); break; case 6: printf("Sbado"); break; case 7: printf("Domingo"); break; } }

Operadores Lgicos<> Los operadores lgicos bsicos son tres: <> &&<> AND ||<> OR !<> NOT (El valor contrario) 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 introducido */ { 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"); }

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 otras condiciones unidas por operadores lgicos. 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 bucle. 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++; } } Sentencia DO...WHILE Su sintaxis es: <> do{ sentencia1; sentencia2; }while (condicin); Con esta sentencia se controla la condicin al final del bucle. 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. /* Uso de la sentencia DO...WHILE. */ #include <stdio.h>

main() /* Muestra un men si no se pulsa 4 */ { char seleccion; do{ printf("1.- Comenzar\n"); printf("2.- Abrir\n"); printf("3.- Grabar\n"); printf("4.- Salir\n"); printf("Escoge una opcin: "); seleccion=getchar(); switch(seleccion){ case '1':printf("Opcin 1"); break; case '2':printf("Opcin 2"); break; case '3':printf("Opcin 3"); } }while(seleccion!='4'); } 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: /* Uso de la sentencia FOR. */ #include <stdio.h> main() /* Escribe la tabla de multiplicar */

{ 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); } } Sentencia BREAK Esta sentencia se utiliza para terminar la ejecucin de un bucle o salir de una sentencia SWITCH. 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 del 1 al 100 menos el 25 */ <> { int numero=1; while(numero<=100) { if (numero==25) <> { <> numero++; continue; } printf("%d\n",numero);

numero++; } } 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. 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. 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); } 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 no un valor. En una misma funcin podemos tener ms de una instruccin return. La forma de retornar un valor es la siguiente: <> return ( valor o expresin ); El valor devuelto por la funcin debe asignarse a una variable. De lo contrario, el valor se perder. En el ejemplo puedes ver lo que ocurre si no guardamos el valor en una variable. Fjate que a la hora de mostrar el resultado de la suma, en el printf, tambin podemos llamar a la funcin. /* 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 trabajramos 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 direccin de memoria donde se encuentra la variable o dato. Cualquier modificacin SIafectar 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; 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); }

Para enviar un valor por referencia se utiliza el smbolo & (ampersand) delante de la variable enviada. Esto le indica al compilador que la funcin que se ejecutar tendr que obtener la direccin de memoria en que se encuentra la variable. Vamos a fijarnos en los ejemplos. En el 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 tras 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); } Los argumentos de la funcin main Ya hemos visto que las funciones pueden recibir argumentos. Pues bin, la funcin main no poda ser menos y tambin puede recibir argumentos, en este caso desde el exterior. Los argumentos que puede recibir son: argc: es un contador. Su valor es igual al nmero de argumentos escritos en la lnea de comandos, contando el nombre del programa que es el primer argumento.

argv: es un puntero a un array de cadenas de carcteres que contiene los argumentos, uno por cadena.

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. 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 momento 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 carcteres), es que deberemos indicar en que elemento se encuentra el fin de la cadena mediante el carcter nulo (\0). Esto no lo controla el compilador, y tendremos que ser nosotros los que insertemos este carcter 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 carcter nulo a vector[5]. Es muy sencillo: vector[5]='\0'; . 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: Que no se hayan rellenado todos los elementos (i<19). 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 carcter por teclado. Despus se encuentra un if, que comprueba si se ha rellenado todo el vector. Si es cierto, coloca el carcter nulo en el elemento n20 (cadena[19]). En caso contrario tenemos el else, que asigna el carcter nulo al elemento que almacen el carcter 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 pueden 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++) { printf("Elemento n %d",i+1); scanf("%d",&array[i]); } 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) 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 */ for (x=0;x<3;x++) for (i=0;i<4;i++) printf("%d",numeros[x][i]); } Si al declarar una matriz tambin 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","doming o"}; Para referirnos a cada palabra bastara con el primer ndice: <> printf("%s",dias[i]); Punteros. Un puntero es una variable que contiene la direccin de memoria de otra variable. Se utilizan para pasar informacin entre una funcin y sus puntos de llamada. Declaracin Su sintaxis es la siguiente: <> tipo *nombre; Donde nombre es, naturalmente, el nombre de la variable, y tipo es el tipo del elemento cuya direccin almacena el puntero.

Operadores Existen dos operadores especiales para trabajar con punteros: & y *. l primero devuelve la direccin de memoria de su operando. Por ejemplo, si queremos guardar en el puntero x la direccin de memoria de la variablenum, deberemos hacer lo siguiente: <> x=&num; 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; 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); } Aritmtica de direcciones Es posible desplazar un puntero recorriendo posiciones de memoria. Para ello podemos usar los operadores de suma, resta, incremento y decremento (+, -, ++, - -). Si tenemos un puntero ( p1 ) de tipo int ( 2 bytes ), apuntando a la posicin 30000 y hacemos: p1=p1+5; el puntero almacenar la posicin 30010, porque apunta 5 enteros por encima ( 10 bytes ms ). Estructuras 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 programacin 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 acabamos 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, temporal; 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 estructura, la estructura tiene que estar declarada previamente. Se debe declarar antes de la funcin main. El manejo de las estructuras es muy sencillo, as como el acceso a los campos ( o variables ) de estas estructuras. La forma de acceder a estos campos es la siguiente: <> variable.campo;

Donde variable es el nombre de la variable de tipo estructura que hemos creado, y campo es el nombre de la variable que forma parte de la estructura. Lo veremos mejor con un ejemplo basado en la estructura del captulo 13.1: <> temporal.edad=25; Lo que estamos haciendo es almacenar el valor 25 en el campo edad de la variable temporal de tipo trabajador. Otra carcterstica interesante de las estructuras es que permiten pasar el contenido de una estructura a otra, siempre que sean del mismo tipo naturalmente: <> fijo=temporal; Al igual que con los otros tipos de datos, tambin es posible inicializar variables de tipo estructura en el momento de su declaracin: <> struct trabajador fijo={"Pedro","Hernndez Surez", 32, "gerente"};

Si uno de los campos de la estructura es un array de nmeros, los valores de la inicializacin debern ir entre llaves: <> struct notas { char nombre[30]; int notas[5]; <>}; struct notas alumno={"Carlos Prez",{8,7,9,6,10}}; Estructuras y funciones Podemos enviar una estructura a una funcin de las dos maneras conocidas: 1.- Por valor: su declaracin sera: <> void visualizar(struct trabajador); Despus declararamos la variable fijo y su llamada sera: <> visualizar(fijo); Por ltimo, el desarrollo de la funcin sera: <> void visualizar(struct trabajador datos) /* Paso de una estructura por valor. */ #include <stdio.h> struct trabajador { char nombre[20]; char apellidos[40];

int edad; char puesto[10]; }; void visualizar(struct trabajador); main() /* Rellenar y visualizar */ { struct trabajador fijo; printf("Nombre: "); scanf("%s",fijo.nombre); printf("\nApellidos: "); scanf("%s",fijo.apellidos); printf("\nEdad: "); scanf("%d",&fijo.edad); printf("\nPuesto: "); scanf("%s",fijo.puesto); visualizar(fijo); } void visualizar(struct trabajador datos) { printf("Nombre: %s",datos.nombre); printf("\nApellidos: %s",datos.apellidos); printf("\nEdad: %d",datos.edad); printf("\nPuesto: %s",datos.puesto); } Por referencia: su declaracin sera: <> void visualizar(struct trabajador *); Despus declararemos la variable fijo y su llamada ser: <> visualizar(&fijo); Por ltimo, el desarrollo de la funcin ser: <> void visualizar(struct trabajador *datos) Fjate que en la funcin visualizar, el acceso a los campos de la variable datos se realiza mediante el operador ->, ya que tratamos con un puntero. En estos casos siempre utilizaremos el operador ->. Se consigue con el signo menos seguido de mayor que.

/* Paso de una estructura por referencia. */ #include <stdio.h> struct trabajador { char nombre[20]; char apellidos[40]; int edad; char puesto[10]; }; void visualizar(struct trabajador *); main() /* Rellenar y visualizar */ { struct trabajador fijo; printf("Nombre: "); scanf("%s",fijo.nombre); printf("\nApellidos: "); scanf("%s",fijo.apellidos); printf("\nEdad: "); scanf("%d",&fijo.edad); printf("\nPuesto: "); scanf("%s",fijo.puesto); visualizar(&fijo); } void visualizar(struct trabajador *datos) { printf("Nombre: %s",datos->nombre); printf("\nApellidos: %s",datos->apellidos); printf("\nEdad: %d",datos->edad); printf("\nPuesto: %s",datos->puesto); } Arrays de estructuras

Es posible agrupar un conjunto de elementos de tipo estructura en un array. Esto se conoce como array de estructuras: <> struct trabajador { char nombre[20]; char apellidos[40]; int edad; }; struct trabajador fijo[20]; As podremos almacenar los datos de 20 trabajadores. Ejemplos sobre como acceder a los campos y sus elementos: para ver el nombre del cuarto trabajador, fijo[3].nombre;. Para ver la tercera letra del nombre del cuarto trabajador, fijo[3].nombre[2];. Para inicializar la variable en el momento de declararla lo haremos de esta manera: struct trabajador fijo[20]={{"Jos","Herrero Martnez",29},{"Luis","Garca Snchez",46}}; Typedef Es posible agrupar un conjunto de elementos de tipo estructura en un array. Esto se conoce como array de estructuras: El lenguaje 'C' dispone de una declaracin llamada typedef que permite la creacin de nuevos tipos de datos. Ejemplos: typedef int entero; /* acabamos de crear un tipo de dato llamado entero */ entero a, b=3; /* declaramos dos variables de este tipo */ 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;

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 escribir en l. 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 especificar 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<> crea un fichero de escritura. Si ya existe lo crea de nuevo. <> w+<> crea un fichero de lectura y escritura. Si ya existe lo crea de nuevo. <> a<> abre o crea un fichero para aadir datos al final del mismo. a+<> abre o crea un fichero para leer y aadir datos al final del mismo.

r<> abre un fichero de lectura. r+<> abre un fichero de lectura y escritura. Modo binario <> wb<> crea un fichero de escritura. Si ya existe lo crea de nuevo. <> w+b<> crea un fichero de lectura y escritura. Si ya existe lo crea de nuevo. <> ab<> abre o crea un fichero para aadir datos al final del mismo. a+b<> abre o crea un fichero para leer y aadir datos al final del mismo. rb<> abre un fichero de lectura. r+b<> 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 estamos 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: <> FILE *pf; pf=fopen("datos.txt","r"); if (pf == NULL) printf("Error al abrir el fichero"); 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. 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);

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 carcter <> fputc( variable_carcter , puntero_fichero ); Escribimos un carcter 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); fclose(pf);^b fgetc( puntero_fichero ); Lee un carcter de un fichero ( abierto en modo lectura ). Deberemos guardarlo en una variable. Un ejemplo: <> FILE *pf; char letra; <> if (!(pf=fopen("datos.txt","r"))) /* controlamos si se produce un error */ <> { <> printf("Error al abrir el fichero"); exit(0); /* abandonamos el programa */ } else { letra=fgetc(pf); printf("%c",letra); fclose(pf); }

Un nmero entero <> putw( variable_entera, puntero_fichero ); Escribe un nmero entero en formato binario en el fichero. Ejemplo: <> FILE *pf; int num=3; if (!(pf=fopen("datos.txt","wb"))) /* controlamos si se produce un error */ <> { <> printf("Error al abrir el fichero"); exit(0); /* abandonamos el programa */ } else { fputw(num,pf); /* tambin podamos haber hecho directamente: fputw(3,pf); */ <> fclose(pf); } <> getw( puntero_fichero ); Lee un nmero entero de un fichero, avanzando dos bytes despus de cada lectura. Un ejemplo: <> FILE *pf; int num; if (!(pf=fopen("datos.txt","rb"))) /* controlamos si se produce un error */ { printf("Error al abrir el fichero"); exit(0); /* abandonamos el programa */ } else { num=getw(pf); printf("%d",num); fclose(pf); } Una cadena de carcteres

<> fputs( variable_array, puntero_fichero ); Escribe una cadena de carcteres 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; char nombre[20]="Santiago"; int edad=34; if (!(pf=fopen("datos.txt","w"))) /* controlamos si se produce un error */ { printf("Error al abrir el fichero"); exit(0); /* abandonamos el programa */ } else { fprintf(pf,"%20s%2d\n",nombre,edad); fclose(pf); } <> <> fscanf( puntero_fichero, formato, argumentos ); Lee los argumentos del fichero. Al igual que con un scanf, deberemos indicar la direccin de memoria de los argumentos con el smbolo & ( ampersand ). Un ejemplo: <> FILE *pf; char nombre[20]; int edad; if (!(pf=fopen("datos.txt","rb"))) /* controlamos si se produce un error */ <> { <> printf("Error al abrir el fichero"); exit(0); /* abandonamos el programa */ } else { fscanf(pf,"%20s%2d\",nombre,&edad); printf("Nombre: %s Edad: %d",nombre,edad);

fclose(pf); } Estructuras <> fwrite( *buffer, tamao, n de veces, puntero_fichero ); Se utiliza para escribir bloques de texto o de datos, estructuras, en un fichero. En esta funcin, *buffer ser la direccin de memoria de la cul se recogern los datos; tamao, el tamao en bytes que ocupan esos datos y n de veces, ser el nmero de elementos del tamao indicado que se escribirn. <> fread( *buffer, tamao, n de veces, puntero_fichero ); Se utiliza para leer bloques de texto o de datos de un fichero. En esta funcin, *buffer es la direccin de memoria en la que se almacenan los datos;tamao, el tamao en bytes que ocupan esos datos y n de veces, ser el nmero de elementos del tamao indicado que se leern. Puedes encontrar ejemplos sobre la apertura y cierre de ficheros, as como de la lectura y escritura de datos, en el archivo IMAGECAT.C. Se trata de un programa que crea un catlogo en formato HTML a partir de las imgenes que se encuentran en un directorio determinado. 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 al 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.

Gestin Dinmica de Memoria<> Funciones Como veremos despus, la gestin dinmica memoria se realiza mediante estructuras dinmicas de datos. Fjate que se repite la palabra dinmica. Estas estructuras se diferencian de las estticas ( arrays y estructuras ), en que no tienen un tamao fijo, es decir, no tenemos que indicar su tamao al declararlas, sino que podremos aumentarlo o disminuirlo en tiempo de ejecucin, cuando se est ejecutando la aplicacin. Como puedes ver, las estructuras dinmicas son de gran utilidad. A continuacin veremos las funciones que se encargan de reservar y liberar memoria durante la ejecucin, que se encuentran en la librera alloc.h: malloc( tamao ); Esta funcin reserva en memoria una zona de tamao bytes, y devuelve un puntero al inicio de esa zona. Si no hubiera suficiente memoria retornaraNULL. Ms adelante veremos algunos ejemplos. free( puntero ); Esta funcin libera de la memoria la zona que habamos reservado anteriormente con la funcin malloc. Estructuras dinmicas de datos En funcin de la forma en que se relacionan existen varios tipos de estructuras de datos. Este tipo de estructuras son autorreferenciadas, es decir, contienen entre sus campos un puntero de su mismo tipo. Las ms utilizadas son: <> - pilas - colas - listas Las pilas Este tipo de estructuras se carcteriza porque todas las operaciones se realizan en el mismo lado. Es de tipo LIFO ( Last In First Out ), el ltimo elemento en entrar es el primero en salir. /* 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); struct pila { char nombre[20]; struct pila *ant; }*CAB=NULL,*AUX=NULL; main() /* Rellenar, extraer y visualizar */ { char opc; do { clrscr(); /* borramos la pantalla */ gotoxy(30,8); /* columna 30, fila 8 */ printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la pila"); gotoxy(30,14); printf("4.- Salir"); opc=getch( ); switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3':

visualizar( ); } }while (opc!='4'); <> } void insertar(void) { AUX=(struct pila *)malloc(sizeof(struct pila)); clrscr(); printf("Nombre: "); gets(AUX->nombre); if (CAB==NULL) { CAB=AUX; AUX->ant=NULL; } else { AUX->ant=CAB; CAB=AUX; } } void extraer(void) <> { <> if (CAB==NULL) return; AUX=CAB; CAB=CAB->ant; free(AUX); } void visualizar(void) {

if (CAB==NULL) return; clrscr(); 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 tipopila 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 pasar 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); 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 carcteriza porque insertamos los elementos por un lado y los extraemos por el otro lado. Es de tipo FIFO ( First In FirstOut ), 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];

struct cola *sig; }*CAB=NULL,*AUX=NULL,*FIN=NULL; main() /* Rellenar, extraer y visualizar */ <> { <> char opc; do { clrscr(); gotoxy(30,8); printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la cola"); gotoxy(30,14); printf("4.- Salir"); opc=getch( ); switch(opc) { case '1': insertar( ); break; case '2': extraer( ); break; case '3': visualizar( ); } }while (opc!='4'); } void insertar(void)

{ AUX=(struct cola *)malloc(sizeof(struct cola)); clrscr(); printf("Nombre: "); gets(AUX->nombre); AUX->sig=NULL; if (FIN==NULL) FIN=CAB=AUX; else { FIN->sig=AUX; FIN=AUX; } } void extraer(void) <> { <> if (CAB==NULL) return; AUX=CAB; CAB=CAB->sig; free(AUX); } void visualizar(void) { if (CAB==NULL) return; clrscr(); AUX=CAB; while (AUX!=NULL) { printf("Nombre: %s\n",AUX->nombre); AUX=AUX->sig; }

getch(); } La estructura que utilizaremos ser: <> struct cola { tipo variables; struct cola *sig; }*CAB=NULL,*AUX=NULL,*FIN=NULL; Donde tipo variables sern las diferentes variables que guardaremos en la estructura, struct cola *sig es un puntero que apunta al elemento de tipocola introducido a continuacin, *CAB ser donde guardaremos el primer elemento insertado en la cola, *AUX nos servir para guardar elementos temporalmente y para recorrer la cola al visualizarla y *FIN tomar la direccin del ltimo elemento insertado. Antes de insertar un elemento, deberemos comprobar si la cola est vaca o no. Si lo est deberemos insertar el primer elemento: <> if (FIN==NULL) CAB=FIN=AUX; Si ya existiera algn elemento haremos que FIN->sig apunte al elemento de AUX y a continuacin haremos que FIN tome la direccin de AUX, con lo que FIN apuntar al ltimo elemento insertado. <> FIN->sig=AUX; FIN=AUX; Para extraer un elemento de la cola haremos que el puntero auxiliar AUX tome la direccin del primer elemento insertado, que hemos guardado enCAB. Tras esto haremos que CAB apunte a CAB->sig, es decir, que tome la direccin del segundo elemento insertado, que ahora pasar a ser el primero. Luego liberaremos la zona de memoria apuntada por AUX: AUX=CAB; /* Deberemos controlar que no est vaca: if (CAB==NULL) return; */ <> CAB=CAB->sig; free(AUX); Para visualizar la cola comprobaremos que existan elementos, esto es, que FIN sea distinto de NULL. Hecho esto asignaremos a AUX la direccin deCAB e iremos recorriendo la cola hasta que AUX sea igual a NULL. AUX=CAB; /* Deberemos 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; do { clrscr( ); gotoxy(30,8); printf("1.- Insertar"); gotoxy(30,10); printf("2.- Extraer"); gotoxy(30,12); printf("3.- Visualizar la lista");

gotoxy(30,14); 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 quevamos a crear en la posicin que le corresponda,teniendo en cuenta que la lista deber quedarordenada de menor a mayor. El puntero P compruebasi el campo num de un elemento es menor que elcampo num del elemento introducido. El punteroF se quedar apuntando al elemento de la posicin anterior al elemento que hemos insertado */ void insertar(void) { AUX=(struct lista *)malloc(sizeof(struct lista)); clrscr( ); 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; <>} <> } void extraer(void) { int var; if (CAB==NULL) return; clrscr( ); 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!=NULL) { 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; clrscr( ); 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; Donde tipo variables sern las variables que guardaremos en la estructura, struct lista *sig es un puntero que apunta al elemento de tipo listaintroducido 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 el 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 deCAB 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: Aqu finaliza el tema de la gestin dinmica de 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 muy similar al de una lista normal. Puedes intentar hacerla tu mismo. Otras estructuras, como los rboles son ms complejas y menos utilizadas. Programacin Grfica Conceptos bsicos El estndar de C++ no define ninguna funcin grfica debido a las grandes diferencias entre las interfaces de los distintos tipos de hardware. Nosotros veremos el conjunto de funciones que utiliza Turbo C. La resolucin ms habitual del modo grfico en Turbo C es de 640x480x16. Inicializacin del modo grfico Para poder trabajar en modo grfico primero deberemos inicializarlo. Las funciones a utilizar son estas. <> detectgraph (int *tarjeta , int *modo); Detecta el tipo de tarjeta que tenemos instalado. Si en el primer argumento retorna -2 indica que no tenemos ninguna tarjeta grfica instalada (cosa bastante improbable). <> initgraph (int *tarjeta , int *modo , "path"); Inicializa el modo grfico ( primero hay que usar detectgraph ). En path deberemos indicar el directorio donde se encuentra el archivoEGAVGA.BGI. <> int graphresult( ); Retorna el estado del modo grfico. Si no se produce ningn error devuelve 0, de lo contrario devuelve un valor entre -1 y -16. <> char grapherrormsg(int error);

Retorna un puntero al mensaje de error indicado por graphresult. Finalizacin del modo grfico <> closegraph( ); Cierra el modo grfico y nos devuelve al modo texto. <> restorecrtmode( ); Reestablece el modo de video original ( anterior a initgraph ). /* Inicializacin del modo grfico. */ #include <graphics.h> main() /* Inicializa y finaliza el modo grfico. */ { int tarjeta, modo, error; detectgraph(&tarjeta,&modo); initgraph(&tarjeta,&modo,"C:\\TC\\BGI"); error=graphresult( ); if (error) { printf("%s",grapherrormsg(error)); } else { getch( ); closegraph( ); } } Funciones <> int getmaxx( ); Retorna la coordenada mxima horizontal, probablemente 639. Ej: hm=getmaxx( ); <> int getmaxy( ); Retorna la coordenada mxima vertical, probablemente 479. Ej: vm=getmaxy( ); <> int getx( ); Retorna la coordenada actual horizontal. Ej: hact=getx( ); <> int gety( );

Retorna la coordenada actual vertical. Ej: vact=gety( ); <> moveto(int x , int y); Se mueve a las coordenadas indicadas. Ej: moveto(320,240); <> setcolor(color); Selecciona el color de dibujo y texto indicado. Ej: setcolor(1); o setcolor(BLUE); <> setbkcolor(color); Selecciona el color de fondo indicado. Ej: setbkcolor(4); o setbkcolor(RED); <> int getcolor( ); Retorna el color de dibujo y texto actual. Ej: coloract=getcolor( ); <> int getbkcolor( ); Retorna el color de fondo actual. Ej: fondoact=getbkcolor( ); <> int getpixel(int x , int y); Retorna el color del pixel en x,y. Ej: colorp=getpixel(120,375); <> cleardevice( ); Borra la pantalla. Ej: cleardevice( ); Funciones de dibujo <> putpixel(int x , int y , color); Pinta un pixel en las coordenadas y color indicados. Ej: putpixel(100,50,9); <> line(int x1 , int y1 , int x2 , int y2); Dibuja una linea desde x1,y1 a x2,y2. Ej: line(20,10,150,100); <> circle(int x , int y , int radio); Dibuja un crculo del radio indicado y con centro en x,y. Ej: circle(320,200,20); <> rectangle(int x1 , int y1 , int x2 , int y2); Dibuja un rectngulo con la esquina superior izquierda en x1,y1 y la inferior derecha en x2,y2. Ej: rectangle(280,210,360,270); <> arc(int x , int y, int angulo1 , int angulo2 , int radio); Dibuja un arco cuyo centro est en x,y, de radio r, y que va desde angulo1 a angulo2. Ej: arc(200,200,90,180,40); <> setlinestyle(int estilo, 1 , grosor); Selecciona el estilo de linea a utilizar. El estilo puede tomar un valor de 0 a 4. El grosor puede tomar dos valores: 1 = normal y 3 = ancho. Ej:setlinestyle(2,1,3); Funciones de relleno

<> floodfill(int x , int y , int frontera); Rellena el area delimitada por el color indicado en frontera comenzando desde x,y. Ej: floodfill(100,30,12); <> setfillstyle(int pattern , int color); Selecciona el patrn y el color de relleno. El patrn puede tomar un valor de 0 a 12 Ej: setfillstyle(1,9); <> bar(int x1 , int y1, int x2 , int y2); Dibuja una barra ( rectngulo ) y si es posible la rellena. Ej: bar(200,200,400,300); <> bar3d(int x1 , int y1, int x2 , int y2 , int profundidad , int tapa); Dibuja una barra en 3d, son los mismos valores que bar adems de la profundidad y la tapa: 0 si la queremos sin tapa y 1 si la queremos con tapa. Ej:bar3d(100,100,400,150,40,1); <> pieslice(int x , int y , int angulo1 , int angulo2 , int radio); Dibuja un sector. Hace lo mismo que arc, pero adems lo cierra y lo rellena. Ej: pieslice(250,140,270,320,50); Funciones de escritura de texto <> outtextxy(int x , int y , char *); Muestra el texto indicado ( puede ser un array o puede escribirse al llamar a la funcin ) en las coordenadas x,y. Ej: outtextxy(50,50,"Esto es texto en modo grfico"); <> settextstyle(int fuente , int direccin , int tamao); Selecciona el estilo del texto. Las fuentes ms comunes son las que van de 0 a 4. La direccin puede ser: 0 = horizontal y 1 = vertical. El tamao puede tomar un valor de 1 a 10. Ej: settextstyle(2,0,5); <> setviewport(int x1 , int y1 , int x2 , int y2 , int tipo); Define una porcin de pantalla para trabajar con ella. La esquina superior izquierda est determinada por x1,y1 y la inferior derecha por x2,y2. Para tipo podemos indicar 1, en cuyo caso no mostrar la parte de un dibujo que sobrepase los lmites del viewport, o distinto de 1, que s mostrar todo el dibujo aunque sobrepase los lmites. Al activar un viewport, la esquina superior izquierda pasar a tener las coordenadas (0,0). Para volver a trabajar con la pantalla completa, deberemos escribir: viewport(0,0,639,479,1);. <> clearviewport( ); Borra el contenido del viewport. Aqu concluye el tema del modo grfico. Hay algunas funciones ms, aunque su complejidad es mayor. Generalmente no se suelen utilizar ms que las aqu descritas, pero puedes investigar en la ayuda de Turbo C para conocer alguna otra.

Investigar todo lo referente a Libreras o Bibliotecas

Una librera es un conjunto de recursos (algoritmos) prefabricados que puede utilizar el programador para realizar determinadas operaciones. Las declaraciones de las funciones utilizadas en estas libreras junto con algunas macros y constantes predefinidas que facilitan su utilizacin, se agrupan en ficheros de nombres conocidos que suelen encontrarse en sitios predefinidos. Por ejemplo, en los sistemas UNIX, en /usr/include. Estos ficheros se suelen llamar "de cabecera" porque es tradicin utilizar las primeras lneas del programa para poner las directivas #include que los incluir en el cdigo fuente durante la fase de preprocesado. Libreras son trozos de cdigo que contienen alguna funcionalidad pre-construida que puede ser utilizada por un ejecutable. Por supuesto, las libreras contienen en su interior variables y funciones; si como suponemos, son libreras C++, lo ms probable es que estas variables y funciones estn encapsuladas en forma de clases. De forma general, el trmino librera se utiliza para referirse a un conjunto de mdulos objeto .obj (resultados de compilacin) agrupados en un solo fichero que suele tener las extensiones .LIB, .OBJ, .BPI [6] y .DLL. Estos ficheros permiten tratar las colecciones de mdulos como una sola unidad, y representan una forma muy conveniente para el manejo y desarrollo de aplicaciones grandes, adems de ser un concepto muy frtil para la industria del software, ya que permiten la existencia de las libreras de los propios compiladores y de un mercado de utilidades y componentes adicionales. Son las denominadas libreras 3pp (de terceras partes), en referencia a que no son incluidas de forma estndar con los compiladores, ni creadas por el programador de la aplicacin. En este sentido el software se parece a cualquier otro mercado de componentes. Adems de las libreras ms o menos extensas que acompaan a los compiladores, pueden adquirirse otras, que permiten aadir a nuestros programas las funcionalidades ms diversas sin necesidad de ser un experto en cada rea de la programacin y sin necesidad de que tengamos que estar reinventando la rueda constantemente. Tipos En lo que respecta al lenguaje C++, existen tres tipos fundamentales de libreras que son : Librera Estndar La librera estndar ANSI C++ define la denominada que debe acompaar a cada implementacin del compilador que se adhiera al estndar. Es decir: el Estndar determina cuales son, como se llaman y como se utiliza este conjunto de algoritmos que deben acompaar (como mnimo) a cada implementacin del compilador que quiera llamarse "Estndar". De otro lado, C++ incluye todas las funciones de la primitiva librera estndar de C mas otras nuevas. Las primeras se han mantenido por razn de compatibilidad, aunque el diseo e importancia de las nuevas cambia drsticamente la filosofa del propio lenguaje. Los ficheros de cabecera del C++ Estndar previstos para compatibilidad con el antiguo C, utilizan los mismos nombres .h para los ficheros de cabecera que este. Son los siguientes: <assert.h>, <ctype.h>, <errno.h>, <float.h>, <limits.h>, <locale.h>, <math.h>, <setjmp.h>, <signal.h>, <stdarg.h>, <stddef.h>, <stdio.h>, <stdlib.h>, <string.h>, <time.h> Componentes

A grandes rasgos, podemos decir que la Librera Estndar C++ comprende los siguientes elementos: La denominada Librera Estndar de Plantillas abreviadamente STL.

Una utilidad de entrada/salida de flujos. Una utilidad local (locale) Una clase string para manejo estandarizado de cadenas de caracteres. Una clase complex para manejo y representacin estandarizada de nmeros complejos. Una clase valarray optimizada para la manipulacin de matrices numricas. Un esquema para describir de modo uniforme el entorno de ejecucin mediante la utilizacin de una clase estndar denominada numeric_limits y especializacin para cada uno de los tipos de datos fundamentales. Utilidades para manejo de memoria. Soporte para utilizacin de juegos de caracteres y signos de diversos idiomas. Utilidades para manejo de excepciones. Funcionalidad Si atendemos a su funcionalidad, pueden agruparse en: Clasificacin: Clasifican caracteres ASCII, como letras, caracteres de control (no imprimibles), Maysculas/minsculas etc. Se definen en la cabecera <ctype.h>. Entradas/Salidas de Consola: Estas son las denominadas entrada/salida estndar. Se refieren al teclado y a la pantalla (no pueden utilizarse directamente en las aplicaciones de interfaz grfica).

Conversin: Convierten caracteres y cadenas de caracteres desde formato alfabtico a numrico de diversos tipos (float, int, long). Tambin realizan la conversin inversa, de formatos numricos a representaciones alfabticas y de maysculas a minsculas y viceversa. Diagnstico: Son rutinas destinadas a comprobaciones, a descubrir y corregir posibles errores. Directorio: Rutinas para manejo de directorios y sus direcciones (path names). En linea (Inline): Rutinas para versiones inline de funciones. El compilador genera el cdigo correspondiente para las versiones inline cuando se utiliza #pragma intrinsic o si se solicita optimizacin al compilador (optimizacin de tiempo de ejecucin). Entrada/Salida. Son rutinas que proporcionan manejo de flujos y operaciones de Entrada/Salida a bajo nivel (de Sistema Operativo). Manipulacin. Manejo de cadenas y bloques de memoria: copiar, comparar, convertir y buscar. Matemticas: Para realizar clculos matemticos. De Memoria: Proporcionan asignacin dinmica de memoria. Miscelnea. Se agrupan aqu rutinas varias, como las que posibilitan saltos (goto) no locales y las que manejan diferencias de tipo cultural o de lenguaje. Por ejemplo representacin de nmeros, de moneda, formatos de fecha y hora, clasificacin de tipo alfabtico, etc. Control de proceso. Rutinas que permiten invocar y terminar nuevos procesos desde otra rutina. Fecha y hora. Incluyen rutinaspara conversin y manipulacin de variables de medida del tiempo(fecha y hora).

Argumentos variables. Rutinas utilizadas cuando se usan listas variables de argumentos, como en los casos de printf(), vscanf(), etc. Utilizacin Para utilizar una funcin de librera hay que incluirla en nuestro programa. Para hacerlo se necesitan tres cosas (en realidad las exigencias son las mismas que con cualquier otra funcin, la diferencia estriba en la forma en que se realizan los pasos b y c): a: Incluir en el cdigo fuente las invocaciones a las funciones que estamos utilizando. Ejemplo: printf("Esto es una llamada a la funcin \"printf\" de librera\n"); b: Incluir en el cdigo fuente los prototipos de dichas funciones. Puesto que los prototipos ya estn incluidos en los ficheros estndar de cabecera, hay que indicar al compilador que los incluya. Esto se realiza poniendo en nuestro fuente (normalmente al principio) una directiva de preprocesado #include que seala el fichero de cabecera que se debe aadir. Por ejemplo, si el manual indica que la funcin printf est definida en el fichero de cabecera stdio.h ponemos en nuestro cdigo: #include <stdio.h> c: Incluir en el fuente las definiciones de las funciones utilizadas. Como alternativa se puede indicar al compilador que tales definiciones estn en ficheros compilados previamente. En este ltimo caso se dice que las definiciones de las funciones estn en libreras de las que existen dos tipos: estticas (.LIB, .OBJ y .BPI) ydinmicas (.DLL). Toda la informacin que necesita el compilador est contenida en los ficheros de cabecera, por lo que las operaciones correspondientes son realizadas de forma automtica; con la sola condicin de que los ficheros y libreras correspondientes sean accesibles al compilador. No se debe olvidar que todas las cosas en la Librera Estndar C++ (que no estn en ficheros de cabecera .h), se han definido en un espacio de nombres denominado std, por lo que es preciso referirse a l especficamente cuando se quieran utilizar estos recursos. Funciones y macros Hay que sealar que algunas funciones pueden venir implementadas de dos formas: como macro y como funcin; por ejemplo, la funcin isalnum, contenida en <ctype.h>. Esto significa que adems de estar implementada como una funcin en la correspondiente librera (que se utiliza con los argumentos sealados en el manual), est definida como una macro de preprocesado en <ctype.h>, de forma que salvo indicacin contraria, al realizar la compilacin, el preprocesador transforma la llamada del programador en otra serie de sentencias equivalentes que utilizan los mismos argumentos. El resultado es que en el cdigo resultante, que luego pasa al compilador y al enlazador, no existe nada parecido a una llamada a una funcin isalnum(tcnicamente el proceso es una sustitucin inline de la funcin de librera. Para evitar que esto ocurra y por consiguiente que la llamada a islanum nunca llegue a producirse, basta con indefinir la correspondiente directiva; lo que se hace incluyendo al principio del cdigo y debajo de la lnea #include <ctype.h>, una linea de preprocesado adecuada, en este caso: #undef

isalnum, con lo que el #define del preprocesador quedar sin efecto, con el resultado de que todas las invocaciones a isalnum de nuestro cdigo sern respetadas por el preprocesador; ms tarde, el enlazador cargar el cdigo de isalnum (que extrae de la librera) con el resto de nuestro programa, y colocar en cada punto de nuestro cdigo donde aparezca una invocacin a dicha funcin, un salto a la direccin adecuada. En estos casos, el resultado es el mismo en ambas modalidades: como macro (por defecto) o como funcin de librera. La eleccin de una u otra es cuestin de optimizacin; para tomar una decisin es necesario comprobar y valorar dos aspectos: El tamao del ejecutable que resulta en uno y otro caso: posiblemente mayor si se utiliza la funcin muchas veces y se adopta la macro. La velocidad de ejecucin. Posiblemente mayor si se utiliza la funcin muchas veces (en bucles muy largos) y se utiliza la macro. Librera clsica Se pude decir que esta Librera es parte de la Librera Estndar correspondiente al C clsico. La calidad de un compilador C++ viene determinada en gran medida por la calidad y cantidad de su RTL; por su grado de adherencia al Estndar (debe incluir todos sus elementos) y por el grado de soporte que proporciona para la plataforma concreta a que se destina. Librera estticas Denominadas tambin libreras-objeto, son colecciones de ficheros objeto .obj (compilados) agrupados en un solo fichero de extensin .LIB y .OBJ. Los prototipos de las funciones utilizadas en estas libreras, junto con algunas macros y constantes predefinidas que facilitan su uso, se agrupan en ficheros denominados "de cabecera", porque es tradicin utilizar las primeras lneas del programa para poner las directivas #include que los incluirn en el fuente durante la fase de preprocesado. As pues, las libreras estticas se componen de uno o varios ficheros .lib, .obj o .bpi junto con uno o varios ficheros de cabecera (generalmente .h). Durante la fase de compilacin, el enlazador incluye en el ejecutable los mdulos correspondientes a las funciones de librera que hayan sido utilizadas en el programa, de forma que entran a formar parte del ejecutable, de ah su nombre: Libreras enlazadas estticamente. Dejando aparte consideraciones de comodidad y rapidez, el resultado de utilizar una de tales libreras no se diferencia en nada al que puede obtenerse programando las funciones o clases correspondientes y compilndolas como un mdulo ms de nuestra aplicacin. El compilador Borland C++ dispone de una herramienta especfica para la creacin y manejo de libreras estticas; el ejecutable TLIB.EXE. Librera dinmicas Otra forma de aadir funcionalidad a un ejecutable son las denominadas libreras de enlazado dinmico, generalmente conocidas como DLLs, acrnimo de su nombre en ingls ("Dynamic Linked Library"). Estas libreras se utilizan mucho en la programacin para el SO Windows. Este Sistema contiene un gran nmero de tales libreras de terminacin .DLL,

aunque en realidad pueden tener cualquier otra terminacin .EXE, .FON, .BPI, .DRV etc. Cualquiera que sea su terminacin, de forma genrica nos referiremos a ellas como DLLs, nombre por el que son ms conocidas. La programacin tradicional de aplicaciones Windows utilizando la API del Sistema es en realidad una sucesin de llamadas a este tipo de libreras externas. De hecho, este Sistema Operativo es en realidad un conjunto de tales DLLs. La mayora de los ficheros de disco asociados con el sistema son de este tipo, y se ha llegado a afirmar que escribir una DLL es escribir una extensin del propio Windows. Como utilizar Libreras Desde la ptica del programador C++, la utilizacin de Libreras comprende dos aspectos totalmente diferenciados: Su utilizacin y quizs laconstruccin de alguna de ellas si nuestras aplicaciones son medianamente grandes. En cuanto al primer punto, es seguro que como mnimo utilice algunas de la "Librera Estndar". En cuanto a su construccin, si se dedica a esto de programar en C++, antes o despus pondr manos a la obra. Por cierto: Hay empresas de software cuya principal actividad es precisamente fabricar y vender libreras. Cualquiera que sea el caso, tanto la utilizacin como la construccin, son diferentes segn se trate de libreras estticas o dinmicas.