PDF de programación - Tema 5: Funciones y Módulos

Tema 5:

Funciones y Módulos





Objetivos del tema: Uno de los pilares de la programación estructurada es el
realizar un diseño modular y descendente (top-down) del problema a
resolver. Hasta ahora todos los problemas que hemos hecho constan de una
única unidad: la función main o principal. De este modo no es posible
realizar un diseño descendente del problema ya que todo el cómputo debe
realizarse en una única unidad.

En este capítulo mostraremos cómo el lenguaje de programación C da
soporte al diseño descendente mediante los programas multi archivo y el uso
de funciones, fragmentos de código relativamente independientes que reciben
una serie de parámetros y devuelven un dato como resultado del proceso que
realiza.

Por otro lado, las funciones dan soporte a la representación computacional
de la funcionalidad de los objetos del mundo real, de modo similar a como
las variables permiten representar sus propiedades.

.





Programación



2/25



Índice

Índice ...........................................................................................................................................2

1

2

Funciones y diseño estructurado .........................................................................................4

Funciones en el lenguaje C..................................................................................................5

2.1

Definición de una función ...........................................................................................5

2.2

Variables locales..........................................................................................................8

2.3

Paso de parámetros por valor y por referencia ............................................................9

2.4

Independencia de las funciones.................................................................................12

2.5

Declaración de funciones: prototipos ........................................................................13

3 Modificadores de almacenamiento de las variables ..........................................................14

3.1

register .......................................................................................................................15

3.2

auto ............................................................................................................................15

3.3

extern .........................................................................................................................15

3.4

static...........................................................................................................................17

4

Programas multi archivo....................................................................................................18

4.1

Funciones...................................................................................................................18

4.2

Variables....................................................................................................................20

4.3

Definiendo la interfaz de un módulo: archivos de cabecera......................................20

4.3.1

Ejemplo de un programa multi archivo .............................................................21

Programación



3/25

5

Principales funciones de las librerías estándar ..................................................................23

5.1

Standard C Math........................................................................................................23

5.2

Standard C String and carácter ..................................................................................24

6

Ejercicios ...........................................................................................................................25



Programación



4/25



1 Funciones y diseño estructurado

Hasta ahora todos los ejemplos que hemos mostrado constan únicamente de un bloque de
código, el que contenía la función main. En los primeros años de la programación todos los
programas constaban únicamente de un sólo bloque. Este bloque podía llegar a ser tan
grande como se quisiera. Esta aproximación pronto mostró notables desventajas y
debilidades:

• La complejidad del programa resultante era muy alta ya que había demasiadas

líneas que dependían las unas de las otras.

• Como consecuencia del enorme número de dependencias el número de errores era

muy alto y éstos eran difíciles de encontrar.

• Al estar formado todo el programa por una única unidad era muy difícil dividirlo

entre un grupo de programadores.

Esto llevó a los diseñadores a buscar formas de dividir los programas en partes lo más
independientes posibles. Como resultado de este esfuerzo surgió la programación
estructurada; en este paradigma la unidad mínima de programación con sentido, nombre
propio y relativa independencia del resto es la función o el procedimiento. Una función o
un procedimiento es un pequeño programa que a partir de unos datos de entrada obtiene
unos resultados. La diferencia entre una función y un procedimiento es que la función
devuelve siempre un valor a la línea de código que la invoca, al igual que sucede con las
funciones matemáticas. Los procedimientos están formados por un fragmento de programa
que realiza una determinada tarea sin devolver un valor de retorno.

Las funciones o procedimientos de un programa se pueden agrupar en módulos. Un
módulo es un archivo de código que incluye una serie de funciones o procedimientos que
realizan tareas similares o relacionadas entre sí. Por tanto, en el caso general, un programa
estará compuesto por un conjunto de módulos, cada uno de los cuales a su vez estará
compuesto por un conjunto de funciones o procedimientos.

Programación



5/25

En todo programa existirá una función o un procedimiento principal, que es el primero en
ser ejecutado; en C es la función main. Esta delega parte de sus tareas ejecutando diversas
funciones, que pueden pertenecer a módulos diferentes. Estas funciones, a su vez, se
pueden apoyar en otras funciones. De esta forma se va desglosando las tareas complejas en
tareas más simples hasta que dichas tareas pueden ser realizadas por un único bloque de
código más o menos pequeño.

2 Funciones en el lenguaje C

En cualquier lenguaje de programación las funciones y/o procedimientos son fragmentos
de código independientes con nombre y entidad propia, y se agrupan en módulos de
programación, que no son más que archivos de código independientes que se compilan por
separado y luego se enlazan entre sí para formar el programa completo. La forma de
definir dichos módulos con sus respectivas funciones difiere en cada lenguaje de
programación. En el caso de C debemos de tener en cuenta los siguientes puntos:

• Sólo existen funciones. No se puede escribir ninguna línea de código ejecutable
(excluyendo declaraciones y definiciones) fuera del cuerpo de una función. No se
dispone de procedimientos; para emular la funcionalidad de procedimientos se
utilizan funciones que devuelven como valor el tipo de dato void, esto es, no
devuelven nada.

• No se puede definir una función dentro de otra función; todas las funciones de un

módulo deben de estar en el mismo nivel.

• Siempre debe de existir la función principal main dentro del código del programa;

esta función es la que permite arrancar la ejecución del programa.

2.1 Definición de una función

La sintaxis de definición de una función es la siguiente:

tipo_retorno nombre ( lista de parametros )
{
declaración de variables locales
sentencias
}


Programación



6/25

El tipo_retorno es el tipo de dato correspondiente con el valor devuelto por la función.
Puede ser cualquiera de los del C: char , int, float, etcétera. Por ejemplo, para la función
pow(), una función incluida en las librerías del compilador que permite calcular potencias,
el valor devuelto es el primer argumento elevado al segundo (argumento es lo mismo que
parámetro) y es de tipo double. Si una función no devuelve ningún valor, se debe poner
como tipo de retorno void, que significa “nulo” o “vacio”. Si no se indica ningún tipo de
retorno el compilador supone que es int; no es una buena práctica de programación confiar
en el tipo de retorno por defecto y no indicarlo explícitamente ya que es propenso a fallos
y complica la legibilidad del programa.

El nombre de la función puede ser cualquiera que elija el programador, siguiendo las
mismas reglas que los nombres de las variables. Este nombre es el que se utilizará cuando
se la llame desde la función principal (main) o desde otra función.

Los parámetros o argumentos son los valores sobre los que actúa la función: por ejemplo,
el primer argumento de pow() es la base y el segundo el exponente. La lista de parámetros
es de la forma

tipo1 parametro1, tipo2 parametro2, ... , tipoN parametroN

Hay que especificar de forma separada el tipo de cada parámetro, aunque haya varios del
mismo tipo. Si no se pone el tipo de un parámetro, el compilador supone que es int. Si una
función no utiliza parámetros, se pone dentro de los paréntesis la palabra void. Si no se
pone nada entre los paréntesis, la función no tiene parámetros, pero sin embargo el
compilador no avisa con un error si se llama a la función pasándole algún parámetro.

Las variables definidas dentro del cuerpo de una función se denominan variables locales.
Son variables propias de la función y no existen para el resto del programa. Se declaran,
inicializan y emplean igual que cualquier otra variable. Las vari