Desarr Desarrol ollo lo de Funcio Funciones nes en el Sistem Sistema a Info Informá rmátic tico o
Lic. Lic. Cris Cristia tian n Here Heredia dia 20112011-20 2012 12
UNIDAD TECNICA TECNICA 1: Características del sistema de desarrollo elegido. Objetivo de la unidad: Repasar los conocimientos del lenguaje C. Tiempo estimado: 8 períodos
C COMO LENGUAJE ESTRUCTURADO Aunque el término lenguaje estructurado en bloques no es aplicable estrictamente al lenguaje C, normalmente se considera un lenguaje estructurado por las similitudes en su estructura con ALGOL, Pascal y Modula-2. Técnicamente, un lenguaje estructurado en bloques permite que los procedimientos y funciones se declaren dentro de otros procedimientos o funciones. De esta forma, los conceptos de «global» y «local» se extienden mediante la utilización de reglas de ámbito adicionales, que establecen la «visibilidad» de una variable o procedimiento. C no se puede considerar realmente estructurado en bloques, bloques, puesto puesto que no no permite permite la creación creación de funciones funciones dentro dentro de funciones. funciones. Un lengu lenguaje aje estruct estructura urado do permite permite mucha muchass posibil posibilida idade dess en progra programac mación ión:: Soport Soportaa direct directame amente nte distintas construcciones de bucles, como pueden ser while, do-while y for; la utilización de goto está totalmente prohibida o desaprobada; permite sangrar instrucciones, etc. Los lenguajes estructurados son más recientes que los no estructurados (COBOL, BASIC, etc.). Hoy en día se ha aceptado ampliamente que la claridad de los lenguajes estructurados facilita la programación y el mantenimiento. Realmente, muy pocos programadores podrían considerar seriamente la posibilidad de utilizar un lenguaje no estructurado para nuevos desarrollos de software. El componente principal de la estructura de C es la función (una subrutina independiente de C). En C las funciones son bloques constituyentes en donde tiene lugar toda la actividad del programa. Permiten que tareas distintas de un programa se definan y se codifiquen de forma separada, permitiendo así la modularidad de los programas. Después de crear una función, se puede utilizar de forma apropiada en varias situaciones, evitando la creación de efectos colaterales en otras partes del programa. CARACTERÍSTICAS DEL C. • • • • •
El C es un lenguaje de nivel medio. El código C es muy portable. El C tiene pocas palabras reservadas. El C es un lenguaje para programadores. Es Portable.
CICLO DE CREACIÓN DE UN PROGRAMA O también llamado las fases: FASES DEL DISEÑO Blog: http://mascrisher.blogspot.com
1
FASES DE LA INSTALACION email:
[email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
EDICION Problema ANALISIS
Programa fuente COMPILACION
Especificación PROGRAMACION
Programa objeto MONTAJE
Algoritmo
Programa ejecutable PRUEBA DE EJECUCION
CODIFICACION programa
Aplicación EXPLOTACION Y MANTENIMIENTO
ANÁLISIS En esta fase se establece el producto a desarrollar, siendo necesario especificar los procesos y estructuras de datos que se van a emplear. En el análisis estructurado se pueden emplear varias técnicas como: Diagramas de flujo de datos: Sirven para conocer el comportamiento del sistema mediante representaciones gráficas. Modelos de datos: Sirven para conocer las estructuras de datos y sus características. (Entidad relación y formas normales) Diccionario de datos: Sirven para describir todos los objetos utilizados en los gráficos, así como las estructuras de datos. Definición de los interfaces de usuario: Sirven para determinar la información de entrada y salida de datos. Al final de esta fase tenemos que tener claro las especificaciones de la aplicación. DISEÑO En esta fase se alcanza con mayor precisión una solución optima de la aplicación, teniendo en cuenta los recursos físicos del sistema (tipo de ordenador, periféricos, comunicaciones, etc…) y los recursos lógicos. (sistema operativo., programas de utilidad, bases de datos, etc…). CODIFICACIÓN Consiste en traducir los resultados obtenidos a un determinado lenguaje de programación, teniendo en cuenta las especificaciones obtenidas en el cuaderno de carga. Se deben de realizar las pruebas necesarias para comprobar la calidad y estabilidad del programa. Las pruebas se pueden clasificar en: Pruebas unitarias: Sirven para comprobar que cada módulo realice bien su tarea. Pruebas de interconexión: Sirven para comprobar en el programa el buen funcionamiento en conjunto de todos sus módulos. Pruebas de integración: Sirven para comprobar el funcionamiento correcto del conjunto de programas que forman la aplicación. (el funcionamiento de todo el sistema). EXPLOTACIÓN En esta fase se realiza la implantación de la aplicación en el sistema o sistemas físicos donde van a funcionar habitualmente y su puesta en marcha para comprobar el buen funcionamiento. Actividades a tener en cuenta o realizar: • Instalación del/los programa/s. • Pruebas de aceptación al nuevo sistema. • Conversión de la información del antiguo sistema al nuevo (si hay una aplicación antigua) • Eliminación del sistema anterior. Al final de esta fase se debe de completar la información al usuario respecto al nuevo sistema y su uso. Así como facilitarle toda la documentación necesaria para una correcta explotación del sistema (manual de ayuda, manual de uso, guía de la aplicación, etc.). MANTENIMIENTO Esta es la fase que completa el ciclo de vida y en ella nos encargaremos de solventar los posibles errores o deficiencias de la aplicación. Existe la posibilidad de que ciertas aplicaciones necesiten reiniciar el ciclo de vida. Tipos de mantenimiento: Blog: http://mascrisher.blogspot.com
2
email:
[email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
Mantenimiento correctivo: Consiste en corregir errores no detectados en pruebas anteriores y que aparezcan con el uso normal de la aplicación. Este mantenimiento puede estar incluido en la garantía o mantenimiento de la aplicación. Mantenimiento adaptativo: Consiste en modificar el programa a causa de cambio de entorno gráfico y lógico en el que estén implantados. (Nuevas generaciones de ordenadores, nuevas versiones del sistema operativo, etc.) Mantenimiento perfectivo: Consiste en una mejora sustancial de la aplicación al recibir por parte de los usuarios propuestas sobre nuevas posibilidades y modificaciones de las existentes. Los tipos de mantenimiento adaptativo y perfectivo reinician el ciclo de vida, debiendo proceder de nuevo al desarrollo de cada una de sus fases para obtener un nuevo producto.
ESTRUCTURA GENERAL DE UN PROGRAMA Un programa puede considerarse como una secuencia lógica de acciones (instrucciones) que manipulan un conjunto de objetos (datos) para obtener unos resultados que serán la solución al problema que resuelve dicho programa. Todo programa, en general contiene dos bloques bien diferenciados para la descripción de los dos aspectos anteriormente citados: - Bloque de declaraciones. En él se especifican todos los objetos que utiliza el programa (constantes, variables, tablas, registros, archivos, etc.) indicando las características de estos. Este bloque se encuentra localizado siempre por delante del comienzo de las acciones. - Bloque de instrucciones. Constituido por el conjunto de operaciones que se han de realizar para la obtención de los resultados deseados.
PARTES PRINCIPALES DE UN PROGRAMA Las partes principales de un programa están relacionadas con sus dos bloques ya mencionados. Dentro del bloque de instrucciones podemos diferenciar tres partes fundamentales, como se muestra en la siguiente figura:
Entrada de Datos: La constituyen todas las instrucciones que toman los datos de entrada desde un dispositivo externo y los almacena en la memoria principal para que puedan ser procesados. Proceso o algoritmo: Está formado por las instrucciones que modifican los objetos a partir de su estado inicial (datos de entrada) hasta el estado final (resultados) dejando los objetos que lo contiene disponibles en la memoria principal. Salida de resultados: Conjunto de instrucciones que toman los datos finales (resultado) de la memoria principal y los envían a los dispositivos externos.
ESTRUCTURA DE UN PROGRAMA EN C Los programas en C, consisten en una o más funciones. La única función que siempre debe estar presente es la denominada main(), ya que es la primera en ser llamada cuando comienza la ejecución de programa. La estructura general de un programa en C es la siguiente: #include #define declaración de funciones declaración de variables globales main() { variables locales del main() sentencias } f1() { variables locales de la función f1() sentencias } . Blog: http://mascrisher.blogspot.com
3
email:
[email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
. fn() { variables locales de la función fn() sentencias } Los #include son necesarios cuando ocupamos determinadas sentencias que necesitan sus respectiva bibliotecas para poder ejecutarse. Por ejemplo, por lo general una sentencia de entrada/salida requerirá de la biblioteca stdio; se debe codificar #include
Los #define se ocupan cuando una variable debe tener un valor equivalente a través de todo el programa por ejemplo que la variable PI sea siempre igual a 3.1416; se debe codificar #define PI 3.1416. Las declaraciones de funciones consisten básicamente en establecer que existe una función en algún lugar del programa con una cantidad determinada de variables de entrada y que deberá retornar un determinado tipo de valor. Las variables globales son aquellas que se utilizarán a lo largo de todo el programa, en cambio, las variables locales son aquellas que se usarán sólo en las funciones. El main() es la función principal de un programa en C, siempre debe declararse pues el programa en su inicio la primera función que se lee es el main(). Si n existe nos arrojará un error. Las funciones deben estar previamente declaradas para poder ser utilizadas. Un programa básico deberá contener a lo menos un área para el main() y otras área para los #include.
DIRECTRICES PARA EL PREPROCESADOR El preprocesamiento es el primer paso en la etapa de compilación de un programa -esta propiedad es única del compilador de C. El preprocesador tiene más o menos su propio lenguaje el cual puede ser una herramienta muy poderosa para el programador. Todas las directivas de preprocesador o comandos inician con un #. Las ventajas que tiene usar el preprocesador son: - Los programas son más fáciles de desarrollar, - Son más fáciles de leer, - Son más fáciles de modificar - Y el código de C es más transportable entre diferentes arquitecturas de máquinas. #define El preprocesador también permite configurar el lenguaje. Por ejemplo, para cambiar a las sentencias de bloque de código { ... } delimitadores que haya inventado el programador como inicio ... fin se puede hacer: #define inicio { #define fin } Durante la compilación todas las ocurrencias de inicio y fin serán reemplazadas por su correspondiente { o } delimitador y las siguientes etapas de compilación de C no encontrarán ninguna diferencia. La directiva #define se usa para definir constantes o cualquier sustitución de macro. Su formato es el siguiente: #define Por ejemplo: #define FALSO 0 #define VERDADERO !FALSO La directiva #define tiene otra poderosa característica: el nombre de macro puede tener argumentos. Cada vez que el compilador encuentra el nombre de macro, los argumentos reales encontrados en el programa reemplazan los argumentos asociados con el nombre de la macro. Por ejemplo: #define MIN(a,b) (a < b) ? a : b main() { int x=10, y=20; printf("EL minimo es %d\n", MIN(x,y) ); } Cuando se compila este programa, el compilador sustituirá la expresión definida por MIN(x,y), excepto que x e y serán usados como los operandos. Así después de que el compilador hace la sustitución, la sentencia printf será ésta: printf("El minimo es %d\n", (x < y) ? x : y); Como se puede observar donde se coloque MIN, el texto será reemplazado por la definición apropiada. Por lo tanto, si en el código se hubiera puesto algo como: Blog: http://mascrisher.blogspot.com
4
email: [email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
x = MIN(q+r,s+t); después del preprocesamiento, el código podría verse de la siguiente forma: x = ( q+r < s+t ) ? q+r : s+t; Otros ejemplos usando #define pueden ser: #define Deg_a_Rad(X) (X*M_PI/180.0) /* Convierte grados sexagesimales a radianes, M_PI es el valor de pi */ /* y esta definida en la biblioteca math.h */ #define IZQ_DESP_8 <<8 La última macro IZQ_DESP_8 es solamente válida en tanto el reemplazo del contexto es válido, por ejemplo: x = y IZQ_DESP_8. El uso de la sustitución de macros en el lugar de las funciones reales tiene un beneficio importante: incrementa la velocidad del código porque no se penaliza con una llamada de función. Sin embargo, se paga este incremento de velocidad con un incremento en el tamaño del programa porque se duplica el código.
#undef Se usa #undef para quitar una definición de nombre de macro que se haya definido previamente. El formato general es: #undef El uso principal de #undef es permitir localizar los nombres de macros sólo en las secciones de código que los necesiten. #include La directiva del preprocesador #include instruye al compilador para incluir otro archivo fuente que esta dado con esta directiva y de esta forma compilar otro archivo fuente. El archivo fuente que se leerá se debe encerrar entre comillas dobles o paréntesis de ángulo. Por ejemplo: #include #include "archivo" Cuando se indica se le dice al compilador que busque donde están los archivos incluidos o “include'' del sistema. Usualmente los sistemas con UNIX guardan los archivos en el directorio /usr/include. Si se usa la forma "archivo" es buscado en el directorio actual, es decir, donde el programa esta siendo ejecutado. Los archivos incluidos usualmente contienen los prototipos de las funciones y las declaraciones de los archivos cabecera (header files) y no tienen código de C (algoritmos). #if Inclusión condicional La directiva #if evalua una expresión constante entera. Siempre se debe terminar con #endif para delimitir el fin de esta sentencia. Se pueden así mismo evaluar otro código en caso se cumpla otra condición, o bien, cuando no se cumple ninguna usando #elif o #else respectivamente. Por ejemplo, #define MEX 0 #define EUA 1 #define FRAN 2 #define PAIS_ACTIVO MEX #if PAIS_ACTIVO == MEX char moneda[]="pesos"; #elif PAIS_ACTIVO == EUA char moneda[]="dolar"; #else char moneda[]="franco"; #endif Otro método de compilación condicional usa las directivas #ifdef (si definido) y #ifndef (si no definido). El formato general de #ifdef es: #ifdef #endif Si el nombre de macro ha sido definido en una sentencia #define, se compilará la secuencia de sentecias entre el #ifdef y #endif . Blog: http://mascrisher.blogspot.com
5
email: [email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
El formato general de #ifdef es: #ifndef #endif Las directivas anteriores son útiles para revisar si las macros están definidas -- tal vez por módulos diferentes o archivos de cabecera. Por ejemplo, para poner el tamaño de un entero para un programa portable entre TurboC de DOS y un sistema operativo con UNIX, sabiendo que TurboC usa enteros de 16 bits y UNIX enteros de 32 bits, entonces si se quiere compilar para TurboC se puede definir una macro TURBOC, la cual será usada de la siguiente forma: #ifdef TURBOC #define INT_SIZE 16 #else #define INT_SIZE 32 #endif
VARIABLES Y FUNCIONES EXTERNAS Las variables y argumentos definidos dentro de las funciones son “internas”, es decir, locales. Las variables “externas” están definidas fuera de las funciones — se encuentran potencialmente disponibles a todo el programa (globales) pero NO necesariamente. Las funciones son un conjunto de instrucciones que realizan una tarea específica. En general toman ciertos valores de entrada, llamados parámetros y proporcionan un valor de salida o valor de retorno; aunque en C++, tanto unos como el otro son opcionales, y pueden no existir. Tal vez parezca un poco precipitado introducir este concepto tan pronto en el curso. Sin embargo, las funciones son una herramienta muy valiosa, y como se usan en todos los programas C++, creo que debemos tener, al menos, una primera noción de su uso. A fin de cuentas, todos los programas C++ contienen, como mínimo, una función. Prototipos de funciones En C++ es obligatorio usar prototipos. Un prototipo es una declaración de una función. Consiste en una presentación de la función, exactamente con la misma estructura que la definición, pero sin cuerpo y terminada con un ";". La estructura de un prototipo es: [extern|static] [] (); En general, el prototipo de una función se compone de las siguientes secciones: Opcionalmente, una palabra que especifique el tipo de almacenamiento, puede ser extern o static. Si no se especifica ninguna, por defecto será extern. No te preocupes de esto todavía, de momento sólo usaremos funciones externas, lo menciono porque es parte de la declaración. El tipo del valor de retorno, que puede ser void, si no necesitamos valor de retorno. En C, si no se establece, será int por defecto, aunque en general se considera una mala técnica de programación omitir el tipo de valor de retorno de una función. En C++ es obligatorio indicar el tipo del valor de retorno. Modificadores opcionales. Tienen un uso muy específico, de momento no entraremos en este particular, lo veremos en capítulos posteriores. El identificador de la función. Es costumbre, muy útil y muy recomendable, poner nombres que indiquen, lo más claramente posible, qué es lo que hace la función, y que permitan interpretar qué hace el programa con sólo leerlos. Cuando se precisen varias palabras para conseguir este efecto se puede usar alguna de las reglas más usuales. Una consiste en separar cada palabra con un "_". Otra, que yo prefiero, consiste en escribir la primera letra de cada palabra en mayúscula y el resto en minúsculas. Por ejemplo, si hacemos una función que busque el número de teléfono de una persona en una base de datos, podríamos llamarla "busca_telefono" o "BuscaTelefono". Una lista de declaraciones de parámetros entre paréntesis. Los parámetros de una función son los valores de entrada (y en ocasiones también de salida). Para la función se comportan exactamente igual que variables, y de hecho cada parámetro se declara igual que una variable. Una lista de parámetros es un conjunto de declaraciones de parámetros separados con comas. Puede tratarse de una lista vacía. En C es preferible usar la forma "func(void)" para listas de parámetros vacías. En C++ este procedimiento se considera obsoleto, se usa simplemente "func()". Por ejemplo: int Mayor(int a, int b); •
•
•
•
•
Blog: http://mascrisher.blogspot.com
6
email: [email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
Un prototipo sirve para indicar al compilador los tipos de retorno y los de los parámetros de una función, de modo que compruebe si son del tipo correcto cada vez que se use esta función dentro del programa, o para hacer las conversiones de tipo cuando sea necesario. En el prototipo, los nombres de los parámetros son opcionales, y si se incluyen suele ser como documentación y ayuda en la interpretación y comprensión del programa. El ejemplo de prototipo anterior sería igualmente válido si se escribiera como: int Mayor(int, int); Esto sólo indica que en algún lugar del programa se definirá una función "Mayor" que admite dos parámetros de tipo int y que devolverá un valor de tipo int. No es necesario escribir nombres para los parámetros, ya que el prototipo no los usa. En otro lugar del programa habrá una definición completa de la función. Normalmente, los prototipos de las funciones se declaran dentro del fichero del programa, o bien se incluyen desde un fichero externo, llamado fichero de cabecera, (para esto se usa la directiva #include, que veremos en el siguiente capítulo). Ya lo hemos dicho más arriba, pero las funciones son extern por defecto. Esto quiere decir que son accesibles desde cualquier punto del programa, aunque se encuentren en otros ficheros fuente del mismo programa. En contraposición las funciones declaradas static sólo son accesibles dentro del fichero fuente donde se definen.
EDITOR DE TEXTO Un editor de texto es un programa que permite crear y modificar archivos digitales compuestos únicamente por texto sin formato, conocidos comúnmente como archivos de texto o texto plano. El programa lee el archivo e interpreta los bytes leídos según el código de caracteres que usa el editor. Hoy en día es comúnmente de 7- ó 8-bits en ASCII o UTF-8, rara vez EBCDIC. Elementos.- Dentro de los elementos tenemos: Interfaz Formato Botones de acción y de comandos
http://www.caricatos.net/editor/index.php
FUNCIONES DEFINIDAS POR EL USUARIO Las funciones de usuario son, como su nombre indica, las que el propio usuario declara, de igual manera que declara procedimientos. Las funciones nacen con el propósito de ser subprogramas que siempre tienen que devolver algún valor. Las dos principales diferencias entre procedimientos y funciones son: Las funciones siempre devuelven un valor al programa que las invocó. Para llamar a un procedimiento se escribe su nombre en el cuerpo del programa, y si los necesita, se incluyen los parámetros entre paréntesis. Para invocar una función es necesario hacerlo en una expresión. Las funciones de usuario vienen definidas por un nombre, seguidas de dos paréntesis () entre los que puede haber o no argumentos. Los argumentos son valores que se le pasan a la función cuando se llama. Un ejemplo de una función sin argumentos: #include main () { printf (“\nEste mensaje lo muestra la función main()”); MiFuncion (); } /* Definición de la función MiFuncion() */ MiFuncion () { printf (“\nEste otro lo muestra MiFuncion()”); } • •
FUNCIONES DE LIBRERÍA Blog: http://mascrisher.blogspot.com
7
email: [email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
• • •
Lic. Cristian Heredia 2011-2012
Librería: Conjunto de funciones, que a diferencia de un programa de Lenguaje C, no contiene la función main() Librerías Estándard : Todo compilador que soporte ANSI C contiene al menos las siguientes librerías Archivos encabezado ( Header file): Código de lenguaje C que corresponde a declaraciones y recursos de una
librería, que serán asociados mediante la directiva #include •
Librerías Básicas de Lenguaje C
Manejo de caracteres
Funciones Matemáticas
E/S Básico
ctype.h
math.h
stdio.h
Miscelaneos
Manejo de cadenas
Fecha y hora
stdlib.h
string.h
time.h
LA COMPILACION La compilación es el proceso de traducción de programas fuente a programas objeto. El programa objeto obtenido de la compilación ha sido traducido normalmente al código común del lenguaje de máquina. Para conseguir el programa máquina real se debe utilizar un programa llamado montador o enlazador (linker). El proceso de montaje conduce a un programa en lenguaje máquina directamente ejecutable. El modelo de compilación de C En el grafico se muestran las distintas etapas que cubre el compilador para obtener el código ejecutable.
ENLAZADO La fase de enlazado consiste simplemente en ``reunir'' cada uno de los ficheros objeto producidos en la fase anterior, resultando de este proceso un fichero ejecutable. Si nuestro programa hace uso de librerías externas (la mayoría lo hacen), el código de las funciones utilizadas será añadido también al fichero ejecutable http://www.fismat.umich.mx/mn1/manual/node1.html Qué pasa si está escribiendo un programa en C++ y quiere usar una librería de C? Si hace uso de la declaración de funciones de C, float f(int a, char b); el compilador de C++ adornará el nombre como algo tipo _f_int_char para permitir la sobrecarga de la función (y el enlazado con verificación de tipos). De todas formas, el compilador de C que compiló su librería C definitivamente no decoró ese nombre, por lo que su nombre interno será _f. Así pues, el enlazador no será capaz de resolver sus llamadas tipo C++ a f(). La forma de resolver esto que se propone en C++ es la especificación de enlazado alternativo, que se produjo en el lenguaje sobrecargando la palabra clave extern. A la palabra clave extern le sigue una cadena que especifica el enlazado deseado para la declaración, seguido por la declaración: extern "C" float f(int a, char b); Blog: http://mascrisher.blogspot.com
8
email: [email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
Esto le dice al compilador que f() tiene enlazado tipo C, de forma que el compilador no decora el nombre. Las dos únicas especificaciones de enlazado soportadas por el estándar son «C» y «C++», pero algunos vendedores ofrecen compiladores que también soportan otros lenguajes. Si tiene un grupo de declaraciones con enlazado alternativo, póngalas entre llaves, como a continuación: extern "C" { float f(int a, char b); double d(int a, char b); } O, para archivos de cabecera, extern "C" { #include "Myheader.h" } La mayoría de compiladores disponibles de C++ manejan las especificaciones de enlazado alternativo dentro de sus propios archivos de cabecera que trabajan tanto con C como con C++, por lo que no tiene que preocuparse de eso. Ficheros de cabecera Los principales ficheros de cabecera de C ``suelen ser'' los siguientes: ctype.h: Funciones útiles para la clasificación y el mapeado de códigos. errno.h: Funciones que permiten comprobar el valor almacenado en errno por algunas funciones de librerías. float.h: Funciones que establecen algunas propiedades de las representaciones de tipos real. limits.h: Funciones que establecen algunas propiedades de las representaciones de tipos enteros. math.h: Funciones que sirven para realizar operaciones matemáticas comunes sobre valores de tipo double. stdarg.h: Son declaraciones que permiten acceder a los argumentos adicionales sin nombre en una función que acepta un número variable de argumentos. stdio.h: Macros y funciones para realizar operaciones de entrada y salida sobre ficheros y flujos de datos. stdlib.h y a veces unistd.h: Declaraciones de una colección de funciones útiles y la definición de tipos y macros para usarlas. Entre ellas suele estar la función malloc que permite hacer peticiones de memoria dinámica al sistema. string.h: Declaración de una colección de funciones útiles para manejar cadenas y otros arrays de caracteres. time.h: Declaración de funciones para el manejo de fechas. • • • • • •
• •
• •
LIBRERIAS ANSI C EN C string.h math.h stdio.h time.h stdlib.h ctype.h locale.h signal.h setjmp.h
cstring cmath cstdio ctime cstdlib cctype clocale csignal csetjmp
Librerias Borland conio.h graphics.h http://www.youtube.com/watch?v=cCMQL3RJDlw
EJECUCIÓN DE UN PROGRAMA El siguiente estado es correr el programa ejecutable. Para correr un ejecutable en UNIX, simplemente se escribe el nombre del archivo que lo contiene, en este caso programa (o a.out ). Con lo anterior, se ejecuta el programa, mostrando algún resultado en la pantalla. En éste estado, podría haber errores en tiempo de ejecución ( run-time errors), tales como división por cero, o bien, podrían hacerse evidentes al ver que el programa no produce la salida correcta. Si lo anterior sucede, entonces se debe regresar a editar el archivo del programa, recompilarlo, y ejecutarlo nuevamente.
Blog: http://mascrisher.blogspot.com
9
email: [email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
DEPURACIÓN La depuración es el análisis de un programa para descubrir fallos. El nombre en inglés es “debug”, porque esos fallos de programación reciben el nombre de “bugs” (bichos). Para eliminar esos fallos que hacen que un programa no se comporte como debería, se usan unas herramientas llamadas “depuradores”. Estos nos permiten avanzar paso a paso para ver cómo avanza realmente nuestro programa, y también nos dejan ver los valores de las variables. Como nuestros conocimientos ya nos permiten hacer programas de una cierta complejidad, es el momento de ver formas de descubrir dónde están los posibles errores. Lo haremos desde varios entornos distintos.
OPCIONES DEL DEPURADOR Ejemplos de algunos entornos Turbo C es un compilador antiguo, pero sencillo de manejar, y la depuración también es sencilla con él: El menú “Run” es el que nos permite poner nuestro programa en marcha normalmente (“Run”), pero también el que nos permite avanzar paso a paso por las órdenes que lo forman. Hay dos maneras de hacerlo: “Trace into” va paso a paso por todas las órdenes del programa. Si hay una llamada a una función, también sigue paso a paso por las órdenes que forma esa función. “Step over” es similar, salvo que cuando haya una llamada a una función, ésta se tomará como una única orden, sin ver los detalles de dicha función. En cualquiera de ambos casos, se nos muestra con una línea azul por dónde va avanzando la depuración. •
•
Si queremos observar cómo evoluciona el valor de alguna variable, podemos añadir un “vigía” (en inglés “watch”) desde el menú “Break/Watch. Este vigía quedará en la parte inferior de la pantalla.
Si trabajamos con DevC++ para Windows, la situación no es muy diferente. Primero debemos indicar dónde queremos que se interrumpa el programa (añadir un “breakpoint”), haciendo clic con el ratón en el margen izquierdo de nuestro programa. Esa línea quedará resaltada en color rojo. Ahora ponemos en marcha el programa desde el menú “Depurar”.
http://www.fismat.umich.mx/mn1/manual/node1.html
Blog: http://mascrisher.blogspot.com
10
.
email: [email protected]
3ro de Bachillerato
Desarrollo de Funciones en el Sistema Informático
Lic. Cristian Heredia 2011-2012
Actividades de reforzamiento 1.- Elabore 10 preguntas con sus respuestas 2.- Diseñe un organizador grafico de los temas principales 3.- Añada un comentario al blog 4.- Anote la idea principal del video tutorial. 5.- Elabore una sopa de letras sobre el contenido de esta unidad. Escriba lo que aprendió en un resumen de 10 líneas. ___________________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ______________________________________________________________________________ ____________________________
Blog: http://mascrisher.blogspot.com
11
email: [email protected]
3ro de Bachillerato