Date post: | 06-Jan-2016 |
Category: |
Documents |
Upload: | victor-fabian-barrientos |
View: | 240 times |
Download: | 0 times |
of 26
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 1
Ingeniera en Desarrollo de Software
Primer Semestre
Programa de la asignatura:
Fundamentos de programacin
Unidad 6. Funciones
Clave:
TSU
16141102
Licenciatura
/ 15141102
Universidad Abierta y a Distancia de Mxico
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 2
ndice
Unidad 6: Funciones .......................................................................................................... 3
Presentacin ...................................................................................................................... 3
Propsitos .......................................................................................................................... 4
Competencia especfica ..................................................................................................... 4
6.1. Diseo descendente ................................................................................................... 4
6.2. Definicin, declaracin e invocacin de funciones en c ............................................. 13
6.3. Alcance de las variables ........................................................................................... 21
6.4. Paso de parmetros .................................................................................................. 22
6.4.1. Por valor ................................................................................................................ 23
6.4.2. Por referencia ........................................................................................................ 24
Cierre de la unidad .......................................................................................................... 25
Fuentes de consulta ........................................................................................................ 25
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 3
Unidad 6: Funciones
Presentacin
Lo recomendable es crear mdulos
independientes que realicen cada una de
las tareas especficas y que en conjunto
implementen la solucin del problema. A
esta metodologa se le llama diseo
modular, y est inspirado en la estrategia
divide y vencers.
En esta unidad se explicarn las
funciones, que son el medio por el cual se
implementan los mdulos en lenguaje C.
Se presentar la sintaxis para crear una
funcin y la forma en la que se utilizan.
Adems, se resolver un problema
utilizando el diseo modular para
ejemplificar el tema.
Hasta esta etapa del curso, has aprendido
a utilizar las estructuras de control para
disear soluciones de problemas simples.
Tambin has conocido diferentes formas de
representar los datos involucrados en un
problema, desde simples hasta
estructurados (como arreglos, cadenas y
estructuras). Sin embargo, todas las
soluciones propuestas constan nicamente
de un mdulo (funcin), llamado principal
(en C, main); lo cual no es conveniente
cuando se trata de problemas complejos
que requieran de una serie de tareas para
lograr su solucin, pues sta sera muy
grande y, por lo tanto, difcil de corregir o
modificar.
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 4
Propsitos
En esta unidad:
Identificars los sub-problemas
en que se puede dividir un
problema.
Disears algoritmos
modulares para solucionar un
problema.
Construirs funciones en
lenguaje C que realicen tareas
especficas.
Competencia especfica
Implementar funciones para resolver problemas a travs
del desarrollo de programas modulares escritos en
lenguaje C.
6.1. Diseo descendente
La descomposicin de un programa en mdulos ms pequeos se conoce como el
mtodo de divide y vencers (divide and conquer) o diseo descendente (top-down).
Consiste en dividir un problema en unidades ms pequeas sucesivas hasta que sean
directamente ejecutadas por el procesador, en otras palabras, la solucin del problema
se divide una y otra vez hasta que est expresada en trminos de estructuras de control,
cada uno de los niveles o pasos sucesivos se conoce como refinamiento (stepwise).
La metodologa del diseo descendente consiste en efectuar una relacin entre las etapas
de estructuracin de manera que se relacionen entre s a travs de entradas y salidas de
datos. Es decir, se descompone el problema en etapas de estructuracin jerrquicas, de
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 5
forma que se pueda considerar cada estructura desde dos puntos de vista: qu hace? y
cmo lo hace?
Con lo anterior podemos decir que: un mdulo se caracteriza por realizar una tarea
especfica, posee sus propios datos de entrada llamados parmetros de entrada y su
resultado llamado salida o valor de retorno . El diseo de cada mdulo debe ser
independiente de los otros; si es necesario que exista comunicacin entre ellos, sta
nicamente podr realizarse a travs de los parmetros de entrada y del valor de retorno.
En este sentido, puede ser visto, por otros mdulos, como una caja negra que hacia el
exterior slo muestra qu hace y qu necesita, pero no cmo lo hace.
La creacin de un mdulo conlleva dos partes: la definicin del mdulo y la llamada o
invocacin (ejecucin). La primera consta de tres partes:
Definir los parmetros de entrada;
Definir el valor de retorno;
Escribir todas las instrucciones que le permitirn llevar a cabo la tarea, es decir, un
algoritmo.
La llamada o invocacin a un mdulo es el proceso de ejecutar el conjunto de
instrucciones definidas en el mdulo dado un conjunto de entradas especfico. La forma
general de invocar un mdulo es escribiendo su nombre y entre parntesis los valores de
cada uno de los parmetros de entrada, respetando el orden que con el que se defini.
No existe un mtodo para saber en cunto mdulos se debe dividir un problema, sin
embargo es importante tener en cuenta los siguientes principios del diseo modular:
Las partes altamente relacionadas deben pertenecer a un mismo mdulo.
Las partes no relacionadas deben residir en mdulos diferentes.
Para ejemplificar esta forma de resolver problemas y cmo implementarla, se presenta la
siguiente situacin:
Problema 6.1: Realiza el anlisis y diseo de un programa que lea las temperaturas
promedio mensuales registradas en una ciudad a lo largo de un ao y calcule el promedio
anual. Adems, debe convertir las temperaturas mensuales dadas en grados Celsius a
grados Fahrenheit al igual que el promedio.
Empecemos por hacer un bosquejo de los pasos que se tienen que realizar para llegar al
resultado deseado.
1. Leer las doce temperaturas promedio mensuales
2. Calcular el promedio anual de las temperaturas
3. Convertir las temperaturas promedio mensuales de Celsius a Fahrenheit
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 6
4. Convertir el promedio anual de temperaturas a Fahrenheit
5. Imprimir las temperaturas mensuales en grados Fahrenheit y el promedio anual de
las temperaturas, en Celsius y Fahrenheit.
Para registrar las temperaturas mensuales proponemos utilizar un arreglo de tamao 12.
Y de acuerdo con lo anterior, proponemos tres mdulos: El primero encargado de leer las
temperaturas mensuales dadas en grados Celsius, este mdulo necesita el nombre del
arreglo donde va a almacenar los datos. Otro mdulo encargado de calcular el promedio
de las temperaturas, que recibe como parmetros de entrada el arreglo con las
temperaturas mensuales y devuelve el promedio en grados Celsius. El ltimo mdulo slo
convierte grados Celsius a grados Fahrenheit. Esta informacin se resume en el
diagrama modular que se muestra a continuacin.
Figura 6.1: Diagrama modular del problema 6.1
Es mediante un diagrama modular como se representan de manera grfica los mdulos
que integran la solucin del problema. Y una vez que se han definido, el siguiente paso es
disear el algoritmo de cada uno de ellos.
En primer lugar se muestra el pseudocdigo de los mdulos secundarios.
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 7
Mdulo leerTemps(temp[ ])
Inicio
Desde mes 1 mientras mes 12, mes
mes + 1
Imprimir Proporciona la temperatura del
mes, mes
Leer temps[mes-1]
Fin_Desde
Fin
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 8
Algoritmo 6.1: Algoritmo del mdulo leerTemps(temp[])
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 9
Observa que el ciclo del mdulo leeTemps se inicia con mes igual a 1 y termina cuando mes es 13, se propone as porque se pide la
temperatura de los mes 1, 2, 3,.. 12, as que la variable mes guardara el nmero de mes correspondiente a cada lectura, sin
embargo para almacenar la temperatura en la posicin del arreglo indicada se resta uno (temps[mes-1]), as se guarda desde la
posicin 0 y hasta la posicin 11.
Mdulo promTemps(temp[])
Inicio
suma 0
Desde mes 0 mientras mes 11,
mes mes + 1
suma suma + temps[mes]
Fin_Desde
Regresa (suma/12)
Fin
Algoritmo 6.2: Algoritmo del mdulo promTemps(temp[])
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 10
En contraste con el ciclo del mdulo leerTemp, en este mdulo el contador del ciclo se inicia en 0 y termina en 11 (aunque el valor
que tiene al finalizar el ciclo es 12) pues se utiliza para ir sumando cada uno de los elementos del arreglo, as que la variable mes
indicar cada una de las posiciones del arreglo.
Mdulo aFahrenheit(tempC)
Inicio
tempF = 9 5 tempC + 32
Regresa tempF
Fin
Algoritmo 6.2: Algoritmos de mdulos secundarios del problema 6.1 (pseudocdigo)
A partir de los mdulos secundarios presentados se puede plantear el mdulo principal.
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 11
Mdulo Principal
Inicio
/* Lectura de las temperaturas, invocando al mdulo leerTemps */
Imprimir Ingresa los promedios de temperaturas mensuales
leerTemps(temps[])
/* Clculo del promedio utilizando el mdulo promTemps */
promC promTemps(temps[])
/* Conversin del promedio a grados Fahrenheit, invocando al mdulo aFahrenheit */
promF aFahrenheit(promC)
/* Conversin de las temperaturas mensuales a grados Fahrenheit */
Desde mes 0 mientras mes 11, mes mes + 1
tempsF[mes] aFahrenheit(temps[mes])
Fin_Desde
/* Impresin de temperaturas mensuales en Fahrenheit */
Desde mes 1 mientras mes 12, mes mes + 1
Imprimir Temperatura en Fahrenheit del mes, mes, es: , tempF[mes-1]
Fin_Desde
/* Impresin del promedio en grados Celsius y grados Fahrenheit */
Imprimir El promedio en grados Celsius es: , promC
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 12
Imprimir El promedio en grados Fahrenheit es: , promF
Fin
Algoritmo 6.4: Algoritmo del mdulo principal del problema 6.1 (pseudocdigo)
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 13
Por esta ocasin se deja como ejercicio al lector que realice las representaciones en
diagrama de flujo del mdulo principal, considerando que el smbolo que se utiliza para
llamar a mdulos que no devuelven ningn valor, como es el caso se leerTemps se
muestra a continuacin:
Esto no es caso, del resto de los mdulos secundarios que s devuelven un valor, as que
se utiliza el smbolo de proceso (rectngulo).
Con el ejemplo anterior resaltan indudablemente varias ventajas que proporciona un
diseo modular:
1. Es posible reutilizar cdigo, sta indudablemente es una de las ms importantes
ya que no es necesario escribir el mismo cdigo cada vez que deseamos realizar
una tarea semejante. Por ejemplo, el mdulo aFahrenheit se utiliza 13 veces (12
en el ciclo y una para convertir el promedio) y slo basto definirlo una vez.
2. Fcil deteccin y correccin de errores, dado que el problema fue divido en
pequeos mdulos cada uno responsable de una tarea, si en algn momento
existiera un error en la solucin global, basta identificar cul de las tareas es la que
no se est resolviendo adecuadamente y corregir nicamente aquellos mdulos
involucrados.
3. Fcil modificacin o extensin, si se requiere modificar una tarea del problema o
agregar una nueva, no ser necesario redisear todo el algoritmo, basta con hacer
las modificaciones en los mdulos pertinente.
Un problema se vuelva ms sencillo de solucionar si pensamos de manera modular.
Una vez que se ha ilustrado como realizar una solucin modular, lo siguiente es explicar
cmo se codifica cada uno de los mdulos, tema que se abordar en las siguientes
secciones.
6.2. Definicin, declaracin e invocacin de funciones en C
En el caso particular de C, un mdulo se implementa como una funcin, recuerda que en
la unidad 3 se explic que un programa en C est integrado de varias funciones, donde
leerTemps(temp[])
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 14
una funcin se define como una porcin de cdigo (un conjunto de instrucciones
agrupadas por separado) enfocado a realizar una tarea en especfico, resaltando la
funcin principal main.
Al igual que la funcin principal, cada una de las funciones existe de manera
independiente, tiene sus propias variables, instrucciones y un nombre que las distingue de
las otras.
Adems de los parmetros de entrada (tambin llamados argumentos) que recibe y el tipo
de dato que regresa.
La forma general para definir una funcin es:
( )
{
return;
}
El indica el tipo de dato que la funcin devuelve (puede ser
cualquiera de los tipos bsicos), para lo cual se utiliza la palabra reservada return.
Cuando la funcin no va a devolver ningn dato se especifica mediante el tipo void y no
debe incluir la palabra reservada return. El es el nombre que
le vamos a dar a la funcin y mediante el cual vamos a hacer referencia a ella. Se deben
seguir las mismas reglas que los identificadores de las variables y se recomienda que sea
nemnicos. Enseguida del nombre y entre parntesis va la lista de parmetros, que
consiste de una lista de declaraciones de variables locales que van a contener los datos
de entrada para la funcin, se debe especificar explcitamente el tipo y nombre para cada
uno, separados por comas, aun cuando sean del mismo tipo: tipo1 param1, tipo2
param2,, tipoN paramN. Por ltimo, las instrucciones del cuerpo de la funcin van entre
llaves.
La primera lnea de la definicin de una funcin se conoce como encabezado de la
funcin (en ingls header).
Para ilustrar esto, a continuacin se muestra la codificacin del mdulo aFahrenheit
definido en la seccin anterior.
float aFahrenheit(float tempC)
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 15
{
return ((9.0/5.0)*tempC+32);
}
Programa 6.1: Codificacin del mdulo aFahrenheit
La llamada o invocacin a una funcin se realiza cuando se requiere que se ejecuten las
instrucciones del cuerpo con valores de entrada determinados. Para invocar a una
funcin se tiene que escribir el nombre seguido de los valores que deben coincidir con el
orden, nmero y tipo de los parmetros de entrada dados en la definicin de la funcin y
deben estar encerrados entre parntesis.
La sintaxis general para invocar una funcin ya sea predefinida o definida por el
programador, es la siguiente:
( );
Los parmetros de entrada de una funcin son valores, por lo que pueden estar
determinados por: valores constantes (8,a, 5.2, cadena constante) o una variable (lo
que realmente se pasa a la funcin es el valor almacenado) o una expresin (el parmetro
de entrada real es el resultado de la evaluacin). Por ejemplo, la llamada a la funcin que
definimos se remarcar en la siguiente instruccin:
promF = aFahrenheit(promC);
Al igual que las variables una funcin debe de ser declarada antes de utilizarse, es decir,
antes de invocarla. La declaracin de una funcin se realiza escribiendo el prototipo de la
funcin. El prototipo de una funcin coincide con el encabezado de la misma terminando
con punto y como (;) El prototipo de una funcin slo indica al compilador que existe y
cmo es, ms no lo que hace por lo tanto se debe definir despus. Por ejemplo, el
prototipo de la funcin antes definida sera:
float aFahrenheit(float tempC);
Cabe sealar que en el prototipo de las funciones se puede omitir los identificadores de
los parmetros, ms no los tipos.
Para ilustrar todo lo anterior, a continuacin se muestra la codificacin del algoritmo
modular diseado en la seccin anterior.
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 16
/* Programa: promedioTemp.c
* Descripcin: Calcula el promedio de las temperaturas promedio
* mensuales registrada a lo largo de un ao*/
/* Biblioteca */
#include
#include
/* Variables globales */
int meses = 12;
/* Prototipos de las funciones */
/* Funcin que lee las temperaturas promedio mensuales registradas en un ao*/
void leerTemps( float temps[]);
/* Funcin que calcula el promedio de las temperaturas promedio mensuales
registradas en un ao*/
float promTemps( float temps[]);
/* Funcin que convierte de grados Celsius a grados Fahrenheit */
float aFahrenheit(float tempC);
/* Funcin principal */
main()
{
/* Declaracin de variables locales a main */
float temps[12], tempsF[12], promF, promC;
int mes;
/* Lectura de las temperaturas, invocando a leerTemps*/
printf(Ingresa los promedios de temperaturas mensuales\n);
leerTemps(temps);
/* Clculo del promedio utilizando la funcin promTemps */
promC = promTemps(temps);
/* Conversin del promedio a grados Fahrenheit, invocando al
mdulo aFahrenheit */
promF = aFahrenheit(promC);
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 17
/* Conversin de las temperaturas promedio mensuales a grados
Fahrenheit, invocando al mdulo aFahrenheit */
for(mes = 0; mes
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 18
float suma=0;
for(mes = 0; mes
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 19
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 20
Figura 6.2: Ejecucin del programa promedioTemp.c
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 21
6.3. Alcance de las variables
El alcance de las variables es la parte del programa dentro de la cual se pueden utilizar.
Cuando son declaradas fuera del cuerpo de cualquier funcin se denominan variables
globales y pueden ser utilizadas en cualquier punto del programa a partir del lugar donde
fueron declaradas, en cambio cuando son declaradas dentro del cuerpo de alguna funcin
se denominan variables locales a sta, es decir slo dentro de esa funcin pueden ser
utilizadas.
Las variables locales que tienen en el mismo nombre pero fueron declaradas en
diferentes funciones, no tienen relacin, son espacios de memoria totalmente
independientes uno de otro. Podemos decir que, son como dos personas diferentes que
tienen el mismo nombre. Por otro lado las variables que se ponen como argumentos en la
declaracin de una funcin se consideran locales a estas. Para ejemplificar lo anterior, se
muestra el siguiente programa, en el cual se distinguen con diferentes colores el alcance
de las variables.
#include
#include
int TAM = 5;
void inicializaA(int A[])
{
int i;
for (i=0; i
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 22
printf(%d ]\n\n\t,A[i]);
}
inicializaA(A);
printf(Arreglo despues de la llamada a inicializaA: A = [);
for (i=0; i
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 23
valores originales. Cuando no se le otorga permisos para que la modifique se dice que es
paso de parmetros por valor, pues en este caso slo se transfiere el valor de la variable,
el cual se almacena en una variable local de la funcin que se est llamando. En cambio,
cuando la funcin puede modificar el valor de la variable se dice que es un paso de
parmetro por referencia, pues en este caso no se pasa slo el valor sino la direccin de
memoria que le corresponde a la variable.
En los siguiente subtemas se explica ms a detalle los dos tipos de paso de parmetro.
6.4.1. Por valor
Cuando se realiza una llamada a una funcin por valor y en sta aparece una variable
como uno de los argumentos, en realidad no se est pasando la variable sino una copia
del valor que sta contiene, lo cual implica que si dentro de la funcin se modifica el
argumento esto no se ve reflejado en el programa desde el cual se hizo la llamada, pues
son localidades de memoria diferentes (recuerda que en cada llamada a una funcin se
crean nuevas variables y se destruyen una vez finaliza la ejecucin).
#include
#include
void inicializa(int a)
{
a = 0;
printf("\nEl valor de la variable local \"a\" es %d\n\n",a);
}
main()
{
int a=10;
/* Llamada a la funcin incializa */
printf("\nEl valor de \"a\" antes de la llamada es %i\n\n", a);
inicializa(a);
printf("\nEl valor de \"a\" despues de la llamada es %i\n\n", a);
system("pause");
}
Programa 6.3: porValor.c
La ejecucin del programa es:
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 24
Figura 6.3: Ejecucin del programa pasoValor.c
En la ejecucin puedes ver que la variable local a main no se modifica, esto es porque se
pasa una copia del valor que almacena cuando se realiza la llamada a la funcin
inicializa(a). Este valor se guarda en un espacio de memoria, tambin llamado a, que es
una variable local a la funcin y que existe mientras sta se ejecuta. Observa que el
cambio si se realiza en la variable local de la funcin inicializa.
6.4.2. Por referencia
La llamada a una funcin por referencia s modifica el valor de la variable, pues lo que
realmente se est pasando es la direccin de memoria asignada a la variable para que la
funcin pueda modificar el valor. En C los arreglos siempre se pasan por referencia, ya
que el nombre del arreglo en realidad almacena la direccin de memoria donde se
encuentra almacenado el primer elemento del arreglo. De esta manera cuando se realiza
una llamada a una funcin y se escribe el identificador de un arreglo como parmetro, se
est pasando la direccin. Para ejemplificar lo anterior se muestra la ejecucin del
programa pasoReferencia.c que se present en un subtema anterior.
Figura 6.4: Ejecucin del programa pasoRefencia.c
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 25
En la ejecucin del programa se observa que despus de la llamada a la funcin cambia
el estado del arreglo A.
Finalmente, cabe mencionar que para realizar la llamada por referencia de una variable
de tipo bsico en lenguaje C es necesario pasar la direccin de la variable para lo cual se
utiliza el operador & seguido del nombre de la variable (&nombre), como se hace en la
funcin scanf, este operador regresa la direccin de memoria que le corresponde a la
variable indicada. Por otra parte, para almacenar la direccin de memoria de una variable
se utiliza una variable de tipo apuntador. Una variable apuntador se encarga de
almacenar una direccin de memoria, la declaracin de una variable apuntador es similar
a la de cualquier otra variable, con la diferencia que se debe escribir un asterisco entre el
tipo de la variable y el identificador. El tema de los apuntadores es muy interesante, sin
embargo, no es uno de los objetivos de este curso.
Para que apliques lo aprendido en esta unidad y a lo largo del curso se propone la
siguiente evidencia de aprendizaje.
Cierre de la Unidad
Felicidades!, aqu concluye el estudio de la Unidad 6. Funciones; tambin de la
asignatura de Fundamentos de programacin y con ella parte de un ciclo de
aprendizaje, desarrollo profesional y personal nico.
Esperamos que los contenidos y actividades a lo largo de la unidad hayan permitido
implementar funciones para resolver problemas a travs del desarrollo de programas
modulares escritos en lenguaje C. Si requieres profundizar o resolver alguna duda sobre
el tema no dudes en consultar a tu Facilitador(a).
Contina con entusiasmo, disciplina y empeo el tercer Cuatrimestre de tu formacin
profesional!
Fuentes de consulta
Deitel H, M., & Deitel P, J. Cmo programar en C/C++. Mxico: Prentice Hall.
Joyanes, L., & Zohanero, I. (2005). Programacin en C. Metodologa, algoritmos y
estructuras de datos. aspao: Mc Graw Hill.
Fundamentos de programacin Unidad 6. Funciones
Ciencias Exactas, Ingeniera y Tecnologa | Desarrollo de Software 26
Kernighan, B., & Ritchie, D. (1991). El lenguaje de programcin C. Mxico:
Prentice-Hall Hispanoamericana.
Lpez, L. (2005). Programacin estructurada en lenguaje C. Mxico: Alfaomega.
Prez, H. (1992). Fsica General (Primera Edicin ed.). Mxico: Publicaciones
Cultura.