INSTITUTO SUPERIOR
TECNOLÓGICO
NORBERT WIENER
Manual del Alumno
ASIGNATURA:
Metodología de
Programación Avanzada con
Visual C++
Tipos de Datos en C.
Hay Varios tipos de Datos básicos en C:
TIPO
I. DESCRIPCIONChar Un solo byte (8 bits) capaz de entender un carácter del conjunto de caracteres local.
Int Un entero , normalmente del tamaño natural de los enteros en la maquina que los ejecuta.
Float Utilizado para números con punto flotante de precisión. P/e: 12.345 .12345e2 o 123495.0e-3
Double Utilizado para números con punto flotante de doble precisión p/e:
Log E= 2.718281828459 ó Sin_per_sec=4.848136811076e-7
Además existen algunos calificadores que se aplican a estos tipos de básicos: Short y Long se aplican a enteros.
La intención es que short y long proporcionen diferentes longitudes de entero donde sea Practico, int será normalmente el tamaño natural para una maquina en particular. A menudo short es de 16 bits y long de 32, por lo tanto, int es de 16 o 32. Cada compilador puede seleccionar libremente los tamaños apropiados para su propio hardware, sujeto solo a las restricciones de que los short's e int's son por lo menos de 16 bits, los long's son por lo menos de 32 bits y el short no es mayor que el int, el cual a su vez no es mayor que long.
Ejemplos short int n; Long int contar ; El calificador signed o unsigned puede aplicarse a char o a enteros. Los números unsigned son >=0. Por ejemplo la declaración : unsigned int numero; es igual a unsigned n;
El tipo long double especifica punto flotante de precisión extendida, igual que los enteros, los tamaños de objetos de punto flotante se definen en la implementación, float, double y long double representan 3 tamaños distintos.
Los archivos de cabecera estándar <limits.h>y <float.h> contienen constantes similares para todos esos tamaños.
Tipos de Enteros y sus Rangos.
TIPO DE ENTERO RANGO BYTES Int -32.768.. 32.767 2 Unsigned int 0 .. 65.535 2 Long -2.147.483.648 ..
2.147.483.647 4 Unsigned long 0 .. 4.294.967.295 4
Tipos de Coma Flotante y Rangos.
TIPO COMA FLOTANTE RANGO BYTES Float 3.4 x 10-38 .. 3.4 x 1038 4 Double 1.7 x 10-308 .. 1.7 x 10308 8 Long Double 3.4 x 10-4932 .. 1.1 x
104932 10
Tipo de Carácter y rangos de Valores. TIPO CARÁCTER RANGO BYTES Char -128 .. 127 1 Unsigned char 0 .. 255 1
Variables en C.
Las variables son datos de un programa cuyo valor almacenado en memoria puede cambiar durante la ejecución del programa, deben ser declaradas con un nombre y un tipo de dato dado al principio del nombre o de la función
ejemplo tipo_de_dato nombre_de_dato ; int contador ;
Existen algunas restricciones en el nombre de las variables y constantes. Los nombres se componen de letras y dígitos; el primer carácter debe ser una letra, el carácter de subrayado ( _ ) cuenta como una letra que algunas veces es útil para hacer mas legible un nombre largo, sin embargo no se debe de comenzar los nombre de variables con este carácter puesto que las rutinas de biblioteca con frecuencia usan tal formato en sus variables.
La practica tradicional de C es usar letras minúsculas para nombre de variables y mayúsculas para las constantes simbólicas.
Al menos los primeros 31 caracteres de un nombre son significativos, para nombre de funciones el numero puede ser menor de 31.
Las palabras reservadas del lenguaje no se pueden utilizar como variables. C hace diferencia entre mayúsculas y minúsculas por lo que "A" es diferente de "a". Una declaración de variable especifica que debe de reservarse memoria para el objeto del tipo especificado y que podemos referirnos a ese objeto por medio de la variable, ademas de que especifica cuanta memoria debe apartarse para esos objetos, tambien implica el como han de interpretarse los datos representandos por cadenas de bits en una localidad de memoria.
Las Variables son datos que tienen un valor dado por el programador por default y nunca cambiara en la ejecución del programa.
Hay diferentes tipos de constantes, las cuales pueden ser declaradas en C de la siguiente forma:
Constantes Enteras. #define IVA 15 ó const int IVA=15. El valor de un entero también se puede hacer constante con un valor Octal o Hexadecimal, un 0 al principio de una constante entera refiere a un octal y un 0x refiere a un hexadecimal. #define IVA 017 ó #define IVA 0xF
Constante Reales. #define PI 3.14159265 ó const float PI=3.14159265
Constante Carácter. Es un entero escrito como un carácter dentro de apostrofos. El valor de una constante de carácter es el valor numérico del carácter en el código ASCII. #define SALIR 's' ó const char SALIR='s'. Existen
caracteres especiales que suelen representar caracteres tales como la comilla, doble comilla, signo ? y son llamados Secuencias de Escape: TIPO DESCRIPCION ‘\n’ Nueva línea ‘\r’ Retorno de carro ‘\t’ Tabulación horizontal ‘\v’ Tabulación Vertical ‘\f’ Avance de pagina ‘\b’ Retroceso de espacio ‘\a’ Alerta(pitido sonoro) ‘\\’ Barra inclinada inversa
‘\’ Comilla simple ‘\’’’ Doble comilla
‘\000’ Numero Octal ‘\xhhh’ Numero hexadecimal
Constante Cadena ó Cadena Literal. Secuencia de 0 o mas caracteres encerrados entre comillas como en:
"Hola mundo" ó /* Hola mundo */
Las comillas no son parte de la cadena, solo sirve para delimitarla.
Constante Enumeración. Una enumeración es una lista de valores enteros constantes.
Enum boolean {NO,YES};
El primer nombre en un Enum tienen valor 0 y el siguiente 1 y as sucesivamente, a menos que sean especificados valores explícitos. Si no todos los valores son especificados, los valores no específicos continúan con la progresión a partir del ultimo valor que si lo fue. Enum{Luis=1, fernando, josué=10, juana=11, paty}
Luis vale 1, fernando vale 2, josué vale 10 juana 11 y paty 12. Operadores en C
Los Operadores son símbolos que permiten al programa llevar acabo funciones de asignación, matemáticas , lógicas y relacionales.
Operadores de Asignación.
TIPO OPERADOR ACCIÓN
Simple = Asignación Simple Compuesta += -= *= /= (Cociente de la división) %= (residuo de división) <<= >>= Asignación suma Asignación Resta Asignación Producto Asignación cociente Asignación módulo Asignación desplazar izq Asignación desplazar der
&= ¡= ^=
Asignación AND bitwise Asignación OR bitwise Asignación XOR bitwise Ejemplo : n+=5; equivale a n=n+5;
Operadores Aritméticos.
TIPO OPERADOR ACCIÓN Unitarios + - -- ++ Signo positivo Signo Negativo Decremento Incremento Binarios + - * / % Suma Resta Producto División Módulo
Ejemplos: n++ es igual ++n y equivale a n=n+1; a*b; a-b; son resta y producto de 2 variables.
En C también existe una prioridad dentro de estos operadores, téngalos en cuenta para el momento de efectuar operaciones en los programas: OPERADOR PRIORIDAD ++ -- * / % + - = 1 1 2 2 2 3 3 4
Operadores Relacionales.
Permiten comparar 2 operandos dando como resultado solo verdadero ó falso (0 ó 1). OPERADOR ACCIÓN < > <= >= == ¡= Menor que.. Mayor que..
Menor o igual que.. Mayor o igual que.. Idéntico ó igual a.. Diferente de.. Ejemplos: a<b; a>=(d*r); z==y
Operadores Lógicos.
Permiten manejar y evaluar expresiones lógicas. OPERADOR OPERACIÓN LÓGICA ¡ && || No (complemento) Y (AND) O (OR) Ejemplos: ¡a-(a*d)&&(x+u)
Operadores de Manipulación de Bits.
Estos operadores de tratamiento de bits (bitwise) ejecutan operaciones lógicas sobre cada uno de los bits de los operandos. Esta operaciones son comparables en eficiencia y en velocidad a sus equivalentes en lenguaje ensamblador.
OPERADOR OPERACIÓN & Y (AND) Lógica bit a bit
| O (OR) ^ O (OR) ~
<< >>
Lógica bit a bit
Lógica bit a bit (OR exclusivo, XOR)
Complemento a uno (inversión de todos los bits)
Desplazamiento de bits a izquierda Desplazamiento de bits a derecha
Ejemplo: 83 = 0101 0011 206= 1100 1100
83^206= 1001 1101 =157
Estructuras de Control en C
Estas preposiciones de control de flujo especifican el orden en que se realizan el procesamiento de datos dentro de los programas. Hay Diferentes Tipos de Flujos de Control:
Estructuras Secuenciales (goto). Estructuras Condicionales (if, switch)
Estructuras Repetitivas (for, while, do-while). Estructuras de Salida (continue, break).
Estructuras Secuenciales.
El orden de Ejecución es una después de otra en el orden especificado.
La sentencia GOTO tiene esta categoría. Es una instrucción conocida en varios lenguajes clásicos de programación, rompe la
secuencia de ejecución del programa bifurcándolo hasta el lugar indicado por la etiqueta, esta instrucción ha sido duramente criticada desde la aparición de la Programación Estructurada ya que tiende a fomentar desorden en el programa, cosa que el Paradigma Estructurado tiende a eliminar. No obstante es indudable que su uso en algunas ocasiones no produce muchos problemas en la comprensión de los programas.
goto salto; Salto: n++ ;
Estructuras Condicionales.
Estructuras formadas por 1 o mas bloques secuenciales que se inician y separan por una serie de palabras clave.
1.- La instrucción IF es utilizada para tomar decisiones entre 2 o
mas opciones, ejecutadas por el hecho de ser cierta o no las expresiones a la que refiere el IF.
If (expresión)Preposición 1 Else Preposición 2 La construcción If (expresión_1) Preposición_1 Else if (expresión_2) Preposición_2 Else if (expresión_3) Preposición_3 :
Establece un bloque de sentencias con opciones múltiples. La sentencia if-else abreviada:
Expresión_condicional ? Preposiciõn_1: Preposición_2
Que equivale a que si se cumple la expresión condicional se ejecuta la preposición 1 y en caso contrario la preposición 2.
2.-La Instrucciõn SWITCH es de decisión múltiple que prueba si
una expresión coincide con uno de un número de valores constantes enteros y traslada el control adecuadamente.
switch (expresión) {
case expre_cte_1: preposición_1; break; case expre_cte_2: preposición_2; break; :
default: preposición_n; }
"expresión" devuelve un valor tipo entero o constante de carácter. "expre_cte" es un numero o una constante carácter. "break"es una orden imperativa de salida de bloque puesto que ya en ese momento se encontrõ un valor que coincidió. "default" indica que si no se cumple ninguna de las opciones se ejecuta la preposición por defecto. Esta instrucción de bloque switch es opcional, puede escribirse o no. "case" es la Etiqueta de 1 o mas valores de expresiones constantes.
La diferencia entre la estructura de control SWITCH y el IF: El switch solo puede comprobar la igualdad.
Las constantes de tipo carácter se convierten automáticamente a enteros.
No pueden existir 2 sentencias Case iguales en el mismo switch.
El bloque switch es usado generalmente para la construcción de menús en los programas.
Estructuras Repetitivas.
Estructuras formadas por 1 o mas bloques secuenciales cuya ejecución se repite un número definido de veces especificado por un numero ó variable.
for (inicialización ; Condición ; Incremento) {
preposiciones; }
"Inicialización" Normalmente es una sentencia de asignación cuya variable se utiliza para el control del bucle.
"Condición" es una condición relacional que determina cuando debe de finalizarse la ejecución del bucle. "Incremento" define como varia la variable de control cada vez que se ejecuta el bucle. Deacuerdo a los valores de inicialización, este incremento también puede ser decrementado.
Eje 1:
For (i=1 ; i<10 ; i++) {
printf ("\n El numero es : %d \n", i ); }
Eje 2:
For (i=100 ; i=1 ; i--) {
printf ("\n El numero es : %d \n", i ); }
Cuando la estructura FOR inicia su ejecución, la variable de inicialización empieza en 1 (Eje 1) la cual solo se evalúa una sola vez, a continuación se verifica la condición y mientras esta no se cumpla se ejecutaran las preposiciones, como paso siguiente la variable de inicialización se modifica (incrementándose o decrementandose) y el ciclo vuelve a empezar.
2.-La instrucción WHILE en C tiene el siguiente formato.
while( expresión_condicional) {
preposiciones; }
Indican que mientras la expresión condicional sea verdadera se llevan acabo las preposiciones. Dentro de las preposiciones de esta estructura se necesita que una de ellas sea la de modificar la variable (s) de la expresión condicional ya que si no se haria un bucle infinito. Si desde un principio la expresión condicional es falsa, las preposiciones no se ejecutaran ni una sola vez.
3.-La instrucción DO-WHILE tiene la siguiente sintaxis:
do
{preposiciones; }
while(expresión_condicional);
En este caso las preposiciones se ejecutaran al menos una vez hasta que llegan a la comprobación del bucle. El ciclo trabaja hasta que la expresión condicional se vuelve falsa, es decir, trabaja mientras la condición es cierta.
Estructuras de Salida.
Tienen como propósito salirse de ciclos y saltar sobre partes del código del programa.
1.-La instrucción BREAK interrumpe la ejecución de un bucle
while, do-while, y for while (cuenta<=100) { preposición_1; if (cuenta>5) break; preposición_2 } preposición_3;
2.-La instrucción CONTINUE se utiliza en bucles para saltar el
resto del cuerpo del bucle, es decir, terminar la iteración. For(x=1; x<=10; x++)
{if(x==4) continue;
printf ("\n %d ", x); }
Estructura de los Programas en C
Un Programa en C esta formado por 1 ó mas funciones que a su vez, contienen una serie de elementos propios. Una de las funciones que deben estar obligatoriamente presente en un programa C es el main. Una función es un grupo de instrucciones que realizan una tarea especifica en el programa, así mismo el programa tendrá que contener una serie de directivas de preprocesador ó archivos de cabecera escritos como # include<*.h> que son archivos de librerÍas con extensión *.h que contienen la declaración de variables y funciones que permiten el funcionamiento y compilación de los programas.
Un ejemplo sencillo podría ser:
Una vez creado un programa en C como el anterior, se debe de ejecutar compilándolo, y esto depende claro esta, del compilador con el que trabaje, pero la siguiente gráfica da los pasos generales para esto:
Un Programa en C contiene varios Elementos que a continuación de Explican:
1.-Tokens.
Existiendo 5 tipos de ellos:
1.1.-Identificadores. Secuencia de caracteres, letras, dígitos y subrayados.
1.2.-Palabras Reservadas. Elementos que son utilizados por el lenguaje exclusivamente para sus procesos.
PALABRA PALABRA PALABRA PALABRA Asm Double New Switch Auto Else Operator Template Break Enum Private This Case Extern Protcted Throw Catch Float Public Try Char For Register Typedef Class Friend Return Union Const Goto Short Unsigned Continue If Signed Virtual Default Inline Sizeof Void Delete Int Statc Volatile Do Long Struct while
1.3.-Comentarios. Tiene 2 formatos:
// Este es un comentario /* Este es otro comentario */
La diferencia entre ellos es que el comentario que empieza con // solo abarca a una línea y los /*.... */ se extienden a varias líneas.
1.4.-Signos de Puntuación.
Todas las sentencias deben de terminar con un punto y coma ; . Otros signos de puntuación son: ¡ % ^ & * ( ) - + = { } ~ [ ] \ ; ' : < > ?, . / "
1.5- Separadores.
Son espacios en blanco, tabulaciones, retornos de carro y avances
de línea.
2.-Funciones.
C utiliza en sus programas las funciones de Biblioteca que están declaradas en los archivos de cabecera (*.h), pero también utiliza las funciones definidas por el usuario. Las funciones tienen el propósito de realizar tareas especificas en el programa, las cuales no deben de llevar acabo mas de 1 trabajo, si no, es recomendable dividirla en otra función, y además no deben ser muy grandes por que entonces pierden legibilidad y eficiencia. Cuando una función es llamada, el control se pasa a la misma para llevar acabo su tarea hasta que la termine, para después regresar de nuevo el control al modulo que lo llamo. En C todas las funciones o son externas o globales. En todo programa una función debe ser : Declarada, Definida y Llamado ó invocada.
2.1-La Declaración de una función representa su prototipo, y en C debe de estar declarada antes de utilizarla. El
prototipo de una función es su cabecera terminada en un punto y coma.
Tipo nombre_función(tipo_1 par_1, tipo_2 par_2 , ... ); Int suma( int x , int y );
Tipo: Especifica que tipo de variable devuelve la función. Se puede establecer cualquier tipo de dato, pero generalmente es el int. nombre_función : Identificador que representa a la función, si el nombre va precedido de un * entonces la función devuelve un apuntador. Una función no devuelve arreglos o funciones. tipo_1 par_1, tipo_2 par_2 , ... : Son llamados Parámetros o argumentos y son las variables que recibe la función cada vez que es invocada. Si no se pasan argumentos a la función, entonces esta línea se sustituye por la palabra clave void. La definición de las variables en C pueden estar situadas en cualquier parte del programa con la condición de preceder a las instrucciones que las utilizan. Los prototipos suelen situarse encima de la función main().
2.2-La Definición de la función consiste en escribir las instrucciones o tarea a realizar dentro del programa, la cual debe de estar en alguna parte del mismo.
Dentro de la definición de las funciones, existe mucho la instrucción "return" la cual tiene 2 funciones:
1.-Salir de la función y regresar el control a la parte de código que la llamo.
2.-Devolver un valor acorde con el tipo que se ha indicado al declarar la función.
La instrucción void es también empleada para definir que una función no devolverá ningún valor
2.3- El llamado de una función, en el lenguaje C es transferir el control a esa función. Cuando se llama a esa función, se proporciona un nombre de función y una lista de parámetros, si es que los hay. Cuando se llama a una función se realizan los siguientes pasos:
2.3.1-El compilador toma nota de la localización desde donde se llamó la función y hace una copia de la lista de parámetros en caso de haberlos.
2.3.2-Se crea temporalmente cualquier espacio de almacenamiento que se requiere para ejecutar la función. 2.3.3-Comienza la ejecución de la función que se llama,
usando copias de los datos que se proporcionaron en la lista de parámetros.
2.3.4-Despues de que la función termina la ejecución, se regresa el control a la función que la llamo y se libera memoria que se usó para la función.
La llamada a una función tiene el siguiente formato: Variable = expresión(parámetros actuales);
Variable: Especifica la variable en donde se guardara el valor devuelto por la función.
Expresión : Especifica una dirección a una función. Puede ser una expresión que es evaluada a una dirección de una función ó simplemente un identificador que corresponde con el nombre de la función llamada.
Parámetros actuales : Son una lista de expresiones separadas por comas. Los valores resultantes son pasados a la función y asignados a sus correspondientes parámetros formales. El numero
de expresiones en la lista debe ser igual al número de parámetros formales y del mismo tipo.
Ejemplos:
if(suma(13,45)<=0) y=calcular(21,78,90);
Otra manera de llamar a las funciones es por el Paso de Parámetros, si tenemos la siguiente función:
La llamada a la función seria: factorial (15); y se calcularía el correspondiente numero factorial del número 15 por que ese es el valor parámetro que le damos.
Un ejemplo completo de esto quedaría de la siguiente manera, observe la manera en que se mandan llamar la función:
Una Consideración especial que se tiene que estudiar es a la
función main(), tan importante en la programación en C, ya que es
una función que engloba todo el corazón del programa en si, además de que es muy útil para hacer mas funcional a los programas y en el siguiente punto se estudiara.
2.4 "argc y argv" Argumentos o Parámetros de la función main(). Algunas veces es de gran utilidad pasarle información al programa escrito en C cuando tu lo corres, y generalmente le pasas información al programa a la función main() vía Argumentos en línea de Comandos. Un argumento en línea de comandos es la información que sigue del nombre del programa en la línea de comandos en el sistema operativo. Hay 2 argumentos especiales que lo implementan argc y argv, estos son usados para recibir la información. El parámetro argc contiene el numero de argumentos en la línea de comandos y es un entero, es siempre por lo menos 1 por que el nombre del programa se
considera como el primer argumento. El parámetro argv es un puntero a un arreglo de punteros de tipo carácter. Cada elemento en este arreglo de punteros corresponde a un argumento en línea de comandos. Todos los argumentos en líneas de comandos son strings.
Por ejemplo, este simple programa imprime "Hola" y tu nombre en la pantalla si tu tecleas tu nombre después del nombre del programa.
Se debe de declarar apropiadamente a argv y la forma mas común de hacerlo es: char *argv[ ] ;
Los corchetes vacíos significa que el arreglo es de una longitud indeterminada, y se puede accesar a los argumentos de manera indexada, es decir, argv[0] tiene el primer argumento, argv[1] tiene al segundo argumento y así continua.
Otro ejemplo simple de esta manera de manejo de información con la función main() es el siguiente, llamado countdown.c :
El programa cuenta de forma descendente desde un valor dado (el cual es especificado en la línea de comandos DOS), y suena en la computadora un beep (es decir un pequeño sonido) cuando llega al cero. Como todo argumento en las líneas de comandos son strings, se debe de convertir el argumento a entero con la función atoi(), y observen que si se da un segundo argumento o parámetro al programa llamado display entonces se imprimirá el conteo regresivo en la pantalla si no, no lo hará.
Usualmente se utilizan a argc y argv para obtener comandos iniciales a tu programa, en teoría se pueden tener 32,767 parámetros, pero la mayoría de los sistemas operativos no te permiten mas que unos pocos. Normalmente el uso de estos argumentos es para dar nombres de archivos u opciones al programa. El uso de parámetros en líneas de comandos dará a tus
programas mas profesionalismo y facilidades para el uso de archivos batch.
Cuando un programa en C no requiere de parámetros en líneas de comandos, es practica común especificar a la función main() con la instrucción void dentro de la lista de parámetros de la misma función main(), es decir : main(void) ó simplemente dejar vacío este espacio de parámetros es otra opción valida. Los nombres argc y argv son los nombres comunes para estos parámetros pero se le pueden poner los nombres que se deseen (no cambiando los tipos). También algunos compiladores pueden soportar argumentos adicionales pero asegúrate checando el manual de usuario.
3.-Alcance de las Variables.
Hasta ahora se ha visto la declaración de las variables, es decir, la descripción de un tipo de variable o atributo. Sin embargo restan 2 problemas importantes que deben de discutirse: ¿Hasta que punto una variable está asociada con un almacenamiento real (esto es asignación de memoria)?, y ¿Hasta que punto puede referirse a una variable particular un programa (esto es, cual es el alcance de las variables)?. En C, se conocen a las variables y parámetros que se declaran dentro de una función como variables automáticas. A éstas se les asigna memoria cuando se llama a la función. Cuando termina la ejecución de la función, se pierde la asignación. Por ello las variables automáticas existen solo cuando esta activa la función. Además se dice que las variables automáticas son Locales a la función. Es decir, las variables automáticas se conocen sólo dentro de la función donde están declaradas y otra función no puede referirse a ellas. Las variables automáticas (es decir, parámetros en el encabezado de una función o variables locales que siguen de inmediato a cualquier llave de apertura) pueden declararse dentro de cualquier bloque y existen hasta que éste se acaba. Puede
referirse a la variable atraves de todo el bloque a menos que el identificador de la misma se declare de nuevo en un bloque interno. Dentro del bloque interno, una referencia al identificador es una referencia a la declaración más interna y no puede hacerse referencia a las variables de afuera. La segunda clase de variables en C es la de las variables Externas. A las variables que se declaran fuera de cualquier función se les asigna almacenamiento en el primer punto de donde se les encuentra y existen para el resto de la ejecución del programa. El alcance de una variable externa va desde el punto en que se declaran hasta el final del archivo fuente que lo contiene. Todas las funciones del archivo fuente pueden referirse a este tipo de variable que estén más allá de su declaración y, en consecuencia, se dice que son Globales para dichas funciones.
4.- Recursividad.
Esta es la propiedad que tienen las funciones en C++ de poder llamarse a si mismas. Una función recursiva necesita de una condición de Salida. El típico problema es el del calculo del factorial de un número:
5.- Directivas de Preprocesador.
Instruyen al compilador para que realice ciertas tareas antes de que la compilación del programa se active. La directiva mas común es "#include" que le indica al preprocesador que incluya otro archivo fuente C durante el proceso de compilación, y otra típica es "#define" que es una definición de macros. Es una libertad del programador en C poder crear sus propias librerías con extensión *.h y luego incluirlas de manera general en sus programas con la directiva #include. Como se ha mencionado anteriormente, los
archivos de las directivas #include contienen la declaraciõn de variables y funciones útiles para los programas en C, las mas comunes (por que es un total de 450 funciones y macros) se muestran en la sig. Tabla:
LIBRERÍA DESCRIPCIÓN
Conio.h Permite definir coordenadas de una ventana de texto en pantalla y manipular texto.
Ctype.h Declara funciones para la comprobación de caracteres.
Float.h Define constantes relacionadas con la aritmetica de punto flotante
Graphic.h Permite la manipulación de Graficos
Limits.h Define constantes para el tamaño de los tipos de enteros
Math.h Declara funciones y macros matematicas
Setjmp.h Proporciona una forma de evitar la secuencia normal de llamada y regreso de funciones.
Signal.h DA facilidades para manejar condiciones excepcionales que aparecen durante la ejecución Stdio.h Permite leer y escribir datos de archivos y
dispositivos
Sdlib.h Declara fucniones para conversión númerica, asignación de memoria.
String,h Devclara funciones para manipular cadenas como arreglos de caracteres.
Time.h Declara funciones para la manipulación de fecha y hora.
Alloc.h Declara funciones para el manejo de la memoria. Por ejemplo, en el siguiente programa se imprimirán cadena de caracteres en la pantalla:
printf() es una de las funciones de Salida de caracteres que esta definida en #include<stdio.h>, si yo no incluyera esta librería en el programa habría error en la compilación, y así cada librería *.h tiene definidas una serie de funciones especificas.
El Archivo de Cabecera Stdio.h
Cuando nos referimos a entrada/salida estándar (E/S estándar) queremos decir que los datos o bien se están leyendo del teclado, ó bien se están escribiendo en el monitor de video. Como se utilizan muy frecuentemente se consideran como los dispositivos de E/S por default y no necesitan ser nombrados en las instrucciones de E/S. Esto le quedará claro a lo largo de este capítulo. El primer código es el siguiente:
#include <stdio.h> /* define entrada/salida estandar */ int main()
{ int c;
printf("Introduzca cualquier caracter y presione enter," "X = termina el programa.\n");
do {
c = getchar(); /* Toma un caracter del teclado */ putchar(c); /* Despliega el caracter en el monitor */ }
while (c != 'X'); /* Mientras que sea diferente de X */ printf("\nFin del programa.\n");
return 0; }
La primera cosa por estudiar la tenemos en la primera línea. La instrucción #include <stdio.h> es muy parecida a la instrucción #define que ya hemos estudiado excepto que en lugar de una simple sustitución se lee todo un archivo en este punto. El sistema encontrará el archivo llamado stdio.h y leerá la totalidad del contenido reemplazando la instrucción #include stdio.h. Obviamente el archivo debe contener enunciados válidos de C que pueden ser compilados como parte del programa. Este archivo en particular contiene varias definiciones y prototipos para las operaciones de E/S estándar. El archivo es llamado archivo de cabecera y su compilador incluye una gran variedad de ellos, cada uno con un propósito específico y cualquiera de ellos puede ser incluido en cualquier programa. El compilador C utiliza el símbolo de doble comilla para indicar que la búsqueda del archivo include empieza en el directorio actual de trabajo, y si no se encuentra ahí, la búsqueda continuará en el directorio include tal y como está especificado en el ambiente de su compilador. Además se utilizan los símbolos de "menor que" y "mayor que" para indicar que la búsqueda empieza directamente en el directorio include del compilador. Se pueden utilizar tantos include como sea necesario, y es perfectamente válido que un archivo de cabecera incluya uno o más archivos de cabecera adicionales. Comprenderá a su vez que cuando escriba programas largos, es posible incluir ciertas rutinas comunes en un archivo de cabecera e incluir el mismo como ya se ha descrito.
Continuando con el código de ejemplo. Se define la variable llamada c y se despliega un mensaje en pantalla con la yá conocida función printf ( ), entramos en un bucle que no termina sino hasta que el caracter introducido sea una X mayúscula, dentro del bucle nos encontramos con dos nuevas funciones, una que sirve para leer un caracter desde el teclado y otra que despliega dicho caracter en pantalla. La función getchar ( ) lee un solo caracter desde el
dispositivo estándar de entrada, o sea, el teclado, y lo asigna a la variable llamada c. La siguiente función llamada putchar ( ) utiliza el dispositivo de salida estándar, es decir, el monitor de video, para desplegar el caracter contenido en c. El caracter se despliega en la posición actual del cursor y éste avanza un espacio para el siguiente caracter, por lo tanto el sistema se ocupa del orden de despliegue de los caracteres.
Compile y ejecute este programa para descubrir algunas características adicionales, como el hecho que conforme escriba en el teclado, lo escrito se despliega en el monitor y al presionar la tecla enter se repite la línea completa de texto, tal parece que memoriza los caracteres y luego los vuelve a deplegar.
El Sistema Operativo a Nuestra Ayuda
Es conveniente dar una breve explicación de cómo trabaja el sistema operativo para entender lo que pasa.
Cuando se leen datos desde el teclado bajo el control del sistema operativo, los caracteres se almacenan en un buffer (segmento de memoria RAM temporal) hasta que se introduce un retorno de carro momento en el cual la totalidad de los caracteres se devuelven al programa. Cuando se teclean los caracteres, éstos son mostrados en pantalla uno a la vez. A ésto se le llama eco, y sucedeo en muchas de las aplicaciones que Usted corre en su computadora. Para demostrar lo dicho en el programa anterior, teclee una serie continua de caracteres tal que contenga una X mayúscula, verá que conforme vaya tecleando la 'X' aparece en pantalla, pero una vez que presiona la tecla enter, la llegar la cadena de caracteres al punto donde se encuentra la 'X', ahí termina el programa, lo que sucede es que al presionar la tecla enter se entrega al programa la cadena de caracteres, como el programa señala su fin al encontrar una X mayúscula, los caracteres escritos después de la 'X' no se despliegan en pantalla. Veamos otro código:
#include "stdio.h" #include "conio.h" int main()
{ int c;
printf("Introduzca cualquier caracter, el programa" "termina con una X\n");
do {
c = _getch(); /* Se obtiene un caracter */
putchar(c); /* Se despliega la tecla presionada */ }
while (c != 'X');
printf("\nFin del programa.\n"); return 0;
}
Nuevamente empezamos con el archivo de E/S estándar de cabecera, luego definimos una variable llamada c e imprimimos un mensaje de bienvenida. Como en el programa anterior, entramos en un bucle y lo ejecutamos hasta encontrar una X mayúscula, pero la acción es un poco diferente, observe la inclusión del archivo conio.h y de la función _getch ( ) mismos que no forman parte del estándar ANSI-C pero que están disponibles en la mayoría de los compiladores escritos para DOS. La función llamada _getch ( ) es una función para obtener un caracter que difiere de la función getchar ( ) en que no depende de DOS. Ësta función lee un caracter sin hacer eco en pantalla entregando el caracter inmediatamente al programa.
Tenga en cuenta que la función _getch ( ) no está incluida en el estándar ANSI-C y por lo tanto puede no estar disponible en todos los compiladores, además utilizar ésta función puede hacer el progama menos portable a otras máquinas, si su compilador soporta
la función, compile este programa y observe su funcionamiento comparado con el programa anterior, verá que al presionar la tecla enter no coloca una nueva línea con el retorno de carro, para corregir esta situación tenemos el siguiente programa:
#include <stdio.h> #include <conio.h>
#define RC 13 /* Define RC igual a 13 */ #define AL 10 /* Define AL igual a 10 */ int main()
{ int c;
printf("Introduzca cualquier caracter, X para terminar.\n"); do
{
c = _getch(); /* Se obtiene un caracter */ putchar(c); /* Despliega la tecla presionada */
if (c == RC) putchar(AL); /* Si es retorno de carro */ /* coloca una nueva linea */
}
while (c != 'X');
printf("\nFin del programa.\n"); return 0;
}
Tenemos dos nuevos enunciados que definen los códigos de caracter para la nueva línea (linefeed en inglés, traducido en este programa como "alimentar línea", AL), y para el retorno de carro (carriage return, "retorno de carro", RC), si Usted consulta una tabla de códigos ASCII verá por qué éstos términos se han definido como 10 y 13. En el programa principal, después de desplegar el caracter introducido en pantalla lo comparamos con RC, y si es igual además desplegamos una nueva línea, AL.
Le recomiendo ampliamente la compilación y ejecución de cada programa de ejemplo para un mejor entendimiento de la mecánica de las funciones aquí presentadas. Le toca ahora el turno a los números enteros.
Entrada numérica
Estudie el siguiente programa: #include <stdio.h>
int main() {
int numero;
printf("Introduzca un numero de 0 a 32767, el programa" "finaliza con un 100.\n");
do {
scanf("%d", &numero); /* Lee un valor entero */ printf("El numero es %d\n", numero);
}
while (numero != 100); printf("Adios!\n"); return 0;
}
La mecánica del programa es bastante similar a lo que hemos estado trabajando, excepto que definimos una variable de tipo int llamada numero y el bucle continua hasta que el valor introducido sea 100. En lugar de leer un solo caracter tal y como lo hemos hecho en los programas anteriores, ahora leemos un número completo con una sola llamada a la función llamada scanf ( ), esta función es muy similar a la conocida printf ( ) solo que se utiliza para introducir datos en lugar de desplegarlos. Observe en la línea donde se encuentra la función scanf ( ) que ésta no refiere directamente a la variable llamada numero, en lugar de esto, utiliza la dirección de la misma (o sea, un puntero a la variable), ya que
espera le sea retornado un valor. La función scanf ( ) busca en la línea de entrada hasta encontrar el primer campo de datos, lee los caracteres enteros hasta encontrar un espacio en blanco ó un caracter decimal inválido, en este punto detiene la lectura y retorna el valor encontrado.
Si su sistema utiliza enteros de 2 bytes y Usted introduce un número hasta 32767 inclusive éste se despliega correctamente, pero con números mayores parece haber un error. Por ejemplo, si Usted introduce 32768 se despliega -32768, e introduciendo 65536 el valor desplegado es cero. La explicación de éste fenómeno está en la manera en que está definido una variable de tipo int, el bit más significativo para un patrón disponible de 16 bits para una variable entera es el bit de signo por lo que sólo nos quedan 15 bits para representar el valor, por lo tanto la variable sólo puede tomar valores comprendidos entre -32768 y 32767. Este detalle debe tomarlo en cuenta al momento de hacer sus programas. Lo dicho es válido sólo para los compiladores de 16 bits, aunque existe la cada vez mayor posibilidad de que su compilador utilice valores enteros almacenados en campos mayores de 16 bits, en este caso se aplican los mismos principios excepto que el rango de valores es mayor. Compile y ejecute el programa anterior y experimente con lo anteriormente dicho.
Entrada de Cadenas
Ahora veremos cómo introducir una cadena de caracteres en nuestro siguiente programa, el código es el siguiente:
#include <stdio.h> int main()
{
printf("Introduzca una cadena de caracteres, maximo 25 caracteres.\n");
printf("Una X en la columna 1 termina el programa.\n"); do
{
scanf("%s", cadena);
printf("La cadena es -> %s\n", cadena); }
while (cadena[0] != 'X'); printf("Adios!.\n"); return 0;
}
Este programa es similar al último código que estudiamos, excepto que en lugar de definir una variable de tipo int, definimos una variable de tipo string con un límite de 24 caracteres (recuerde que las cadenas de caracteres deben incluir un caracter nulo al final de la cadena). La variable en la función scanf ( ) no requiere un símbolo de & porque cadena es un array y por definición incluye un puntero. Este programa no requiere mayor explicación.
Cuando compile y ejecute éste programa notará que los enunciados son separados en palabras. Cuando scanf ( ) se utiliza en el modo de entrada de cadena de caracteres lee los caracteres hasta que encuentra el final de la linea ó un caracter en blanco, por lo tanto, lee una palabra a la vez. Experimente introduciendo más de 24 caracteres y observe cómo el sistema maneja una situación de error. Como scanf ( ) no tiene manera de parar la introducción de caracteres cuando el array está lleno, por lo tanto no lo utilice para introducir cadenas de caracteres en un programa importante, aquí lo usamos solamente para propósitos de ilustración.
Entrada/Salida en Memoria
Hablemos ahora de otro tipo de E/S, uno que no tiene salida al mundo exterior pero que permanece en la computadora, el código es este:
#include <stdio.h> int main()
{
int numeros[5], resultado[5], indice; char linea[80]; numeros[0] = 74; numeros[1] = 18; numeros[2] = 33; numeros[3] = 30; numeros[4] = 97;
sprintf(linea,"%d %d %d %d %d\n", numeros[0], numeros[1], numeros[2], numeros[3], numeros[4]);
printf("%s", linea);
sscanf(linea,"%d %d %d %d %d", &resultado[4], &resultado[3], (resultado+2), (resultado+1), resultado);
for (indice = 0 ; indice < 5 ; indice++)
printf("El resultado final es %d\n", resultado[indice]); return 0;
}
En este programa definimos algunas variables, después asignamos algunos valores a las llamadas números para propósitos de ilustración y entonces utilizamos la función sprintf ( ), ésta actúa similar a la función printf ( ) pero en lugar de desplegar los datos a un dispositivo de salida, imprime la cadena formateada en una cadena en memoria. En este caso la cadena vá a la variable llamada linea, porque esta es la cadena que introducimos como primer argumento de la función sprintf ( ). Como la cadena generada continúa en memoria, podemos leerla utilizando la función sscanf (
), le decimos a la función en el primer argumento que linea es la cadena a utilizar para su entrada, el resto de los argumentos se manejan igual que en la función scanf ( ). Observe que en este caso si utilizamos punteros porque necesitamos regresar datos de la función y observe además que utilizamos varias formas para declarar punteros, las primeras dos simplemente declaran la dirección de los elementos del array, mientras que los últimos tres aprovechan el hecho que resultado, sin el subíndice, es un puntero. Finalmente y para agregarle más interés, los datos se despliegan en orden inverso.
¡ Crea Tus Propias Librerías *.h de C !.
Se ha visto hasta ahorita que las librerías de C son archivos con la extensión *.h, y que su objetivo es proporcionar al momento de la compilación la declaración de variables y funciones de todo tipo que lleva a cabo las instrucciones generales de programas, Recordando que para utilizar por ejemplo la función que imprime strings en la pantalla "printf()" se tiene que incluir la librería stdio.h, por que si no, el compilador reportara que tal función no esta declarada, y asi de esta manera, de forma general.
Tambien, se ha explicado en el trancurso de este tutorial que tales librerías estan de manera estandar dentro del lenguaje C, tan solo hay que mandarlas llamar, sin embargo se tiene la gran posibilidad de como programador poder crear Nuestras propias librerías con el código propio relacionados con nuestros programas en donde las mandemos llamar con la linea #include<nombre_de_libreria.h> Esto de poder crear nuestras propias librerías tiene 2 objetivos claros en el momento de la creación de un programa:
Evita tener en un solo código toda la declaración de variables y funciones que hacen muy grande al código
fuente principal, esto propicia un orden especifico y eficiencia en el código final del programa por la razón de no quedar tan grande.
Permite Tener un control mas preciso de tales variables y funciones en el trancurso de la creación del programa, asi de poder tener un acceso facíl al momento de modificaciones futuras.
Puntos ha tomar muy encuenta al momento de crear librerías son los siguientes:
Tomese en consideración que una libreria NO ES UN PROGRAMA, es tan solo la declaración de variables y funciones, NADA MAS.
Por la razón de que no es un programa, DE NINGUNA FORMA tiene que estar en ningun tipo de librería la función MAIN (), ya que esta solo tiene que estar presente en el código principal del programa.
NUNCA tiene que compilarse una librería
Habiendo considerado lo anterior, proceda de la siguiente manera para la creación de su librería:
1.- Tiene que usar cualquier tipo de Editor de Textos, puede ser el mismo Turbo C++, o incluso el NotePad o Edit de DOS creando un Archivo nuevo.
2.- Haga la declaración de sus funciones y Variables tal y como lo haría en el programa *.c o *.cpp y que se utilizaran al momento de compilar su programa.
3.- Al momento de Salvar o guardar su Archivo lo hará con la extensión *.h y Listo.
Hecho Lo anterior debe quedar claro que ya no es necesario declarar funciones y variables en su código principal, esto marcaria un error de redeclaración de variables o funciones.
AHORA! la manera de incluirlos en su programa es de la siguiente forma:
1.- Al momento de agregar tu librería al programa, se utiliza la misma instrucción de preprocesador #include<nombre_de_libreria>, nada mas que ahora se tiene que especificar al compilador que esta librería en especial la tiene que leer desde tu diskette o Disco Duro, por lo tanto lo especificas asi #include<nombre_de_unidad:nombre_de_libreria.h>. Por ejemplo una llamada a una libreria propia podría ser #include<a:mi_mouse.h>, asi especifico que mi librería mi_mouse.h la tiene que leer del diskette de la unidad a: (a: es la unidad mas común para la disquetera, pero si cambia, por ejemplo a b: no importa, coloquela de la manera indicada)o puede ser c: , siendo esta la común para el DD.
2.- Al momento de especificar la unidad de almacenamiento donde se encuentra mi librería *.h se tiene la posibilidad tambien de especificar un path o camino donde se encuentra mi librería. Por ejemplo:
#include<a:\libreria\mi_mouse.h>
Y de esta manera el compilador buscara en la unidad a: en el directorio libreria el archivo mi_mouse.h, y asi se pueden especificar incluso subdirectorios subsecuentes.
3.- Algunos programadores de C estilan para diferenciar entre las librerías de C estandar y las que ellos han creado declarar sus propias librerías de la siguiente forma:
#include"a:\libreria\mi_mouse.h"
es decir, cambian los simbolos de mayor que > y menor que < por dobles comillas, lo cual es valido, el compilador lo reconoce sin ningún problema, pero dejarlos con la forma tradicional no marca ningún problema, es tan solo formas y estilos propios de cada programador.
4.-Se puede No especificar una unidad de almacenamiento al momento de llamar a la nuestras librerías siempre y cuando mi archivo fuente *.c o *.cpp y el archivo *.h se encuentren en el mismo subdirectorio /BIN de Turbo C++, es decir se hallen en /TC/BIN, es decir, que en el programa principal solo especifique #include<mi_mouse.h> .Pero si yo no guardo ahi mis archivos SI tendre que especificarle unidad de almacenamiento y subdirectorios (Si los hay) a la directiva #include<> al momento de llamar mis propias librerías
Por el Hecho de manejar de una manera separada código de un programa principal (es decir el *.h) TENGA CUIDADO de no perder o dañar este archivo, si no, no se compilara su programa, y tedrá que de manera detallada volver a encontrar las variables y funciones utilizados en su programa y volverlas a declarar en un nuevo archivo *.h . Y por Ultimo siempre tenga al momento de compilar su programa con librerías hechas por Usted, el diskette en su unidad lista, para que pueda tener acceso a la librería el compilador.
Nunca trate de Editar las librerías que son estandar del lenguaje C, como tratar de editar el stdio.h agregando mis propias variables o funciones, por que entonces el Compilador no Reconocera nunca mas a la librerí aunque se deshagan las modificaciones hecha por mi.Y siempre tenga en cuenta que las instrucciones anteriores son solo para la creación y uso de MIS PROPIAS librerías, el uso de las librerías estandar de C son de la manera especificada en otras secciones del tutorial.
Archivos en C
El Almacenamiento de datos en estructuras de datos vistas anteriormente solo se generan temporalmente, es decir, cuando termina el programa los datos se pierden. Para ello, una forma de
no perderlos y recuperarlos aun cuando el programa termine es con el manejo de Archivos.
C ve cada uno de los archivos simplemente como un grupo secuenciales de bytes. Cada archivo termina con un marcador de fin de archivo o un número de bytes especificado registrado en una estructura de datos.
Las funciones para manipular los Archivos se encuentran en el
archivo de cabecera <stdio.h> y vale la pena mencionarlos: FUNCIÓN DESCRIPCIÓN
fopen() Abre un flujo fclose() Cierra un flujo
Putc Escribe un carácter en un flujo getc() Lee un carácter desde un flujo fputs() Escribe una cadena en un flujo fgets() Obtiene una cadena de un flujo fseek() Salta al byte especificado en un flujo fprintf() Imprime datos con formato en un flujo fscanf() Lee datos con formato en un flujo
eof() Devuelve verdadero o falso si se halla el fin del archivo.
Los flujos dan canales de comunicación entre el archivo y el
programa. Por ejemplo, el flujo de entrada estándar permite que un programa lea datos desde el teclado, el flujo de salida estándar permite que un programa imprima datos en la pantalla. Un flujo se relaciona con un archivo utilizando una operación de apertura y se desliga del archivo con una operación de cierre.
El flujo de Texto se utiliza con conversiones de Caracteres. Es
decir, puede no haber correspondencia entre lo que se envía al flujo y lo que se escribe en el archivo.
El flujo Binario tiene una correspondencia directa entre lo que se
envía y se escribe en el archivo.
Un archivo es el grupo de información que están en una entidad física real que recibe los datos, ya sea DD o diskette.
Abrir un Archivo puede ser para varios propósitos: lectura,
escritura o ambos, por lo que se utiliza la siguiente función para ello:
FILE fopen(char *f,char *modo); que es lo mismo que fopen (Nombre del Archivo, Modo);
Los modos de Abrir al archivo se especifican en la siguiente tabla: ACCES
O DESCRIPCIÓN. "r" Abre un archivo para lectura. El archivo debe de existir
"w" Abre para escritura. Si el archivo no existe se crea, pero si existe se borra su información para crearla de nuevo.
"a" Abre para escribir al final de el. Si el archivo no existe se crea. "r+" Abre para Escritura/Lectura. El archivo debe existir.
"w+" Abre para Escritura/Lectura. Si el archivo no existe se crea, pero si existe su información se destruye para crearla de nuevo.
"a+" Abre para escribir al final de el y leer. Si el archivo no existe se crea. "rb" Abre un archivo binario para lectura. El archivo debe existir.
"wb" Abre un archivo binario para escritura. Si el archivo no existe se crea, pero si existe su información se destruye para crearla de nuevo.
"ab" Se abre un archivo binario para escribir al final de el. Si el archivo no existe se crea. "rb+" Abre un archivo binario para lectura/Escritura. El archivo debe existir
existe su información se destruye para crearla de nuevo.
"ab+" Abre un archivo binario para lectura y añadir. Si el archivo no existe se crea.
Cerrar un Archivo después de trabajar es algo que debe de
hacerse, si no se hace este se cierra automáticamente cuando finaliza el programa. Se cierra de la siguiente manera:
fclose(FILE *f)
Ejemplo de programa que Escribe y lee carácter por carácter de un archivo las instrucciones usadas son putc y getc. Observe el manejo de fopen y fclose en los siguientes ejemplos.
Int putc(int c, FILE*f); Escribe el carácter c en un archivo apuntado por f
Int getc(FILE *f); Devuelve el carácter leído e incrementa la posición actual del indicador del archivo, si se detecta el fin del archivo se devuelve EOF.
FILE *apuntador establece que "apuntador" es un apuntador a la estructura FILE. La forma de Escribir y leer la información por medio de strings es por medio de las instrucciones fgets y fputs. Int fputs(char *cad, FILE *f);Escribe una cadena de caracteres aun archivo apuntado por f. Int fgets(char *cad, int n, FILE *f); Lee una cadena de Caracteres.
Las instrucciones fread y fwrite se utilizan en archivos en el que se utilizan estructuras para definir la longitud de cada record. Size_t fwrite(void *buffer,size_t num_bytes,size_t n, FILE *f); Escribe n registros de longitud num_bytes desde la memoria apuntada por buffer al archivo f. Size_t fread(void *buffer,size_t num_bytes,size_t n, FILE *f); Lee n registros de num_bytes en la memoria apuntada hacia buffer desde el archivo f.
Gráficos en C
Las funciones que llevan acabo los gráficos en C es permitir generar dibujos y presentaciones de los programas en general (es decir, la forma en que lucen al usuario). Las funciones de salida dependen del adaptador y del monitor que se este utilizando. El controlador seleccionado se carga desde el disco durante la inicialización de la biblioteca de gráficos llamado initgraph(), y se necesita incluir la librería #include<graphics.h>
Para Activar el Modo Gráfico un Programa, este debe de
empezar llamando a la función initgraph(), que inicializa el paquete de gráficos BGI.
Void far initgraph(far *controlador, int far *modo, char far *camino)
Se carga en la memoria el controlador de gráficos correspondiente al numero determinado por el controlador. El parámetro modo apunta a un entero que especifica el modo de vídeo que van a usar las funciones de gráficos. El parámetro camino especifica el directorio donde se encuentra el controlador. Si no se especifica se busca en el directorio actual. Los archivos BGI deben de estar disponibles en el sistema ya que contienen los controladores graficos, sin embargo no es necesario preocuparse por el nombre real del archivo, ya que el controlador queda especificado solamewnte con su número, para ello graphics.h tiene varias macros para esto:
MACRO EQUIVALE A... DETECT 0 CGA 1 MCGA 2 EGA64 4 EGAMONO 5 IBM8514 6
HERCMONO 7 ATT400 8 VGA 9 PC3270 10
Al usar DETECT, initgraph() detecta automáticamente el tipo de HW de vídeo presente en el sistema y selecciona el modo de vídeo con la resolución adecuada.
Para Desactivar el modo gráfico del programa se usa la función void closegraph(void) que implica la devolución al sistema de la memoria que se utilizaba para tener los controladores y las fuentes gráficas en uso.
La Escritura en Modo Gráfico se puede llevar acabo con las
funciones especiales para ello:
Void far outtext(char far *cadena de texto );
Muestra en una pantalla en modo gráfico una cadena de texto en la posición actual (en los modos gráficos no existe un cursor visible, pero la posición actual se conserva como si existiera uno invisible). Void far outtextxy(int x,int y, char far *cad)
Escribe un texto en la posición determinada por las coordenadas x,y en la ventana gráfica.
Para Cambiar el tipo de letra se usa la función:
Void far settextstyle(int fuente, int direccion, int tamaño_car); Establece la fuente activa que usaran las funciones de escritura de texto grafico, tambien se establece la dirección y el tamaño de los caracteres. El parametro fuente determina el tipo de fuente que se va a utilizar. Fuente puede tomar algunos de los siguientes valores:
MACRO VALOR TIPO FUENTE DEFAULT_FONT 0 Mapa de bits 8x8. TRIPLEX_FONT 1 Fuente trazada triple. SMALL_FONT 2 Fuente trazada pequeña. SANS_SERIF_FONT 3 Fuente trazada sans serif.
GOTHIC_FONT 4 Fuente trazada gótica.
El parámetro dirección refiere a la forma de desplegarse, ya sea de izquierda a derecha o de arriba hacia abajo, se determina mediante el valor HORIZ_DIR (0) o VERT_DIR (1).
El parámetro tamaño es un multiplicador que aumenta el tamaño de los caracteres. Puede tomar valores de 0 a 10.
Cabe mencionar que las coordenadas de pantalla modo texto y gráfico cambian de la siguiente manera:
Así que tome en cuenta estas gráficas para modelar sus coordenadas al momento de escribir textos.
Programación Orientada a Objetos con C++ INTRODUCCIÓN.
Actualmente una de las áreas más candentes en la industria y en el ámbito académico es la orientación a objetos. La orientación a objetos promete mejoras de amplio alcance en la forma de diseño, desarrollo y mantenimiento del software ofreciendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo de software: la falta de portabilidad del código y reusabilidad, código que es dificil de modificar, ciclos de desarrollo largos y tecnicas de codificacion no intuituvas.
Un lenguaje orientado a objetos ataca estos problemas. Tiene tres características basicas: debe estar basado en objetos, basado en clases y capaz de tener herencia de clases. Muchos lenguajes cumplen uno o dos de estos puntos; muchos menos cumplen los tres. La barrera más difícil de sortear es usualmente la herencia.
El concepto de programación orientada a objetos (OOP) no es nuevo, lenguajes clásicos como SmallTalk se basan en ella. Dado que la OOP. se basa en la idea natural de la existencia de un mundo lleno de objetos y que la resolución del problema se realiza en términos de objetos, un lenguaje se dice que está basado en objetos si soporta objetos como una característica fundamental del mismo. El elemento fundamental de la OOP es, como su nombre lo indica, el objeto. Podemos definir un objeto como un conjunto complejo de datos y programas que poseen estructura y forman parte de una organización.
Esta definición especifica varias propiedades importantes de los objetos. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto nómero de componentes bién estructurados. En segundo lugar, cada objeto no es un ente aislado, sino que forma parte de una organización jerárquica o de otro tipo.
Beneficios que se obtienen del desarrollo con OOP
Día a día los costos del Hardware decrecen. Así surgen nuevas áreas de aplicación cotidianamente: procesamiento de imágenes y sonido, bases de datos multimediales, automatización de oficinas, ambientes de ingeniería de software, etc. Aún en las aplicaciones
tradicionales encontramos que definir interfases hombre-máquina
"a-la-Windows" suele ser bastante conveniente.
Lamentablemente, los costos de producción de software siguen aumentando; el mantenimiento y la modificación de sistemas complejos suele ser una tarea trabajosa; cada aplicación, (aunque tenga aspectos similares a otra) suele encararse como un proyecto nuevo, etc.
Todos estos problemas aún no han sido solucionados en forma completa. Pero como los objetos son portables (teóricamente) mientras que la herencia permite la reusabilidad del código orientado a objetos, es más sencillo modificar código existente
porque los objetos no interaccionan excepto a través de mensajes; en consecuencia un cambio en la codificación de un objeto no afectará la operación con otro objeto siempre que los métodos respectivos permanezcan intactos. La introducción de tecnología de objetos como una herramienta concepual para analizar, diseñar e implementar aplicaciones permite obtener aplicaciones más modificables, fácilmente extendibles y a partir de componentes reusables. Esta reusabilidad del código disminuye el tiempo que se utiliza en el desarrollo y hace que el desarrollo del software sea mas intuitivo porque la gente piensa naturalmente en términos de objetos más que en términos de algoritmos de software.
Problemas derivados de la utilización de OOP en la actualidad
Un sistema orientado a objetos, por lo visto, puede parecer un paraíso virtual. El problema sin embargo surge en la
implementación de tal sistema. Muchas compañías oyen acerca de
los beneficios de un sistema orientado a objetos e invierten gran cantidad de recursos luego comienzan a darse cuenta que han impuesto una nueva cultura que es ajena a los programadores actuales. Específicamente los siguientes temas suelen aparecer repetidamente:
Curvas de aprendizaje largas. Un sistema orientado a objetos ve al
mundo en una forma única. Involucra la conceptualización de todos los elementos de un programa, desde subsistemas a los datos, en la forma de objetos. Toda la comunicación entre los objetos debe realizarse en la forma de mensajes. Esta no es la forma en que están escritos los programas orientados a objetos actualmente; al hacer la transición a un sistema orientado a objetos la mayoría de los programadores deben capacitarse nuevamente antes de poder usarlo.
Dependencia del lenguaje. A pesar de la portabilidad conceptual de
los objetos en un sistema orientado a objetos, en la práctica existen muchas dependencias. Muchos lenguajes orientados a objetos están compitiendo actualmente para dominar el mercado. Cambiar el lenguaje de implementación de un sistema orientado a objetos no es una tarea sencilla; por ejemplo C++ soporta el concepto de herencia multiple mientras que SmallTalk no lo soporta; en consecuencia la elección de un lenguaje tiene ramificaciones de diseño muy importamtes.
Determinacion de las clases. Una clase es un molde que se utiliza
para crear nuevos objetos. En consecuencia es importante crear el conjunto de clases adecuado para un proyecto. Desafortunadamente la definición de las clases es más un arte que una ciencia. Si bien hay muchas jerarquías de clase predefinidas usualmente se deben crear clases específicas para la aplicación que se este desarrollando. Luego, en 6 meses ó 1 año se da cuenta que las clases que se establecieron no son posibles; en ese caso será necesario reestructurar la jerarquía de clases devastando totalmente la planificación original.
Performance. En un sistema donde todo es un objeto y toda
interaccion es a través de mensajes, el tráfico de mensajes afecta la performance. A medida que la tecnología avanza y la velocidad de microprocesamiento, potencia y tamaño de la memoria aumentan, la situacion mejorará; pero en la situación actual, un diseño de una aplicación orientada a objetos que no tiene en cuenta la performance no será viable comercialmente.
Idealmente, habría una forma de atacar estos problemas eficientemente al mismo tiempo que se obtienen los beneficios del desarrollo de una estrategia orientada a objetos. Deberia existir una metodología fácil de aprender e independiente del lenguaje, y facil de reestructurar que no drene la performance del sistema .
Objetos
Las unidades básicas de construcción, para conceptualización, diseño o programación, son instancias organizadas en clases con características comunes. Estas características comprenden los atributos y procedimientos, denominados operaciones o métodos. Los objetos deben estar basados, hasta donde sea posible, en entidades del mundo real y en conceptos de la aplicación o dominio. Los objetos pueden ser clases o instancias, aunque algunos autoridades en la materia utilizan el término objeto como sinónimo de instancia. El estándar OMG es denominar las descripciones de clases como tipos de objetos y se emplea el término clase para referirse a su realización (implementación). Un objeto es una abstracción encapsulada que tiene un estado interno como dado por una lista de atributos cuyos valores son únicos al objeto. El objeto también conoce la lista de mensajes al que puede responder y como responderá en cada uno.
Así mismo un objeto puede modelar muchas cosas diferentes. Algunos tipos más comunes son como se indican a continuación.
Objetos de dispositivo - Modela dispositivos individuales. Objetos de propiedad - Modela importantes propiedades o
características de la aplicación del dominio
Objetos de roles - Modela personas y los roles que desempeñan en el sistema
Objetos de organización - Modela la organización Objetos de sucesos - Modelar los sucesos
Objetos de interacción - Modela las interacciones entre otros objetos
Explícitamente los objetos pueden ser también:
· Entidades externas que producen o consumen información a ser utilizada en el sistema basado en computadora
· Ocurrencia o sucesos que ocurren en el contexto de operación del sistema
· Papeles que juegan las personas que interactúan con el sistema
· Unidades organizativas que son relevantes para la aplicación · Lugares que establecen el contexto del problema y del funcionamiento general del sistema
· Estructuras que definen clases de objetos o, en casos extremos, clases de objetivos relacionadas
Ejemplos de objetos.
ventanas, iconos, arreglos, pilas, colas, árboles binarios, números complejos. Los datos de un objetos están ocultos y solamente a través de sus funciones pueden ser accesados.
Todos los campos miembros y funciones están completamente en el interior del objeto y son ocultos desde el exterior, lo que significa que están encapsulados.
A las funciones de un objeto también se les conoce como métodos y a los datos como variables.
Estructura de un Objeto.
Un objeto puede considerarse como una especie de cápsula dividida en tres partes:
1 - RELACIONES 2 - PROPIEDADES 3 - METODOS
Cada uno de estos componentes desempeña un papel totalmente independiente:
Las relaciones permiten que el objeto se insterte en la organización y están formadas esencialmente por punteros a otros objetos.
