Programacion Modular

Descargar como pdf o txt
Descargar como pdf o txt
Está en la página 1de 11

Tema 7

FUNCIONES Y PROGRAMACIÓN MODULAR

Objetivo:
Conocer la programación modular y el manejo de funciones.
Comprender el manejo de parámetros de en las funciones.

La construcción de un programa inv olucra la descomposición del problema en


partes independientes (módulos), a esto se denomina Programación Modular.
Existe un lema que dice divide y vencerás, pues sencillamente en muchos
probl emas grandes y complejos mejor es resolverlos por partes. Entonces muchas
veces se hace una descomposición de un programa en subprogramas, más cortos
y sencillos.

6.1. Módulos.

Es un conjunto de líneas de código que realizan una función bien definida, que
puede ser un cálculo matemát ico, una conversión de datos, un tratamiento sobre
un archivo. De ésta manera natural un programador divide una tarea en varias
tareas.

6.2. Cohesión y acoplamiento


En el proceso de desarrollo de un programa, se va descomponiendo paso a paso,
generalmente de lo general a lo particular, es decir una función genéricamente
descrita se divide en algo más concreto y así sucesivamente, a esto se denomina
descomposición de arriba abajo (TOP DOWN) o refinamiento progresivo.
Gráficamente esto se representa en forma de árbol. La figura 6.1 muestra una
descomposición del problema que calcula el área de un triángulo.

Existen muchas maneras de descomponer un programa, varios módulos, pocos,


cada módulo con pocas líneas, etc. pero ¿Cuál es la mejor descomposición
modular ?. Hay alguna mejor manera de hacerlo. Para responder a esto existen
dos conceptos de “calidad” de un descomposición modular. Ambos conceptos se
constituyen en una métrica, se trata de : La cohesión y el acoplamiento.

Cohesión: Al grado en el que módulo e s más completo y compacto


Acoplamiento: Al grado de que un módulo puede interferir en otro.

6.3. Niveles de modularización en C.

Existen dos niveles: A nivel de ficheros y a nivel de funciones.


Me to do l o gí a de l a P ro g ram ació n I 59

En el primer caso un se puede dividir un programa en distintos archivos (ficheros)


juntos conforman el programa complet o: leer.c, calcular.c, mostrar.c.

Calcular el area de un
triángulo

Leer datos Realizar cálculos Mostrar resultados

El segundo nivel que es aquello que interesa se hace usando funciones, de hecho
como se dijo anteriormente en el lenguaje C todo se hace a través de funciones,
pues como se ha ido escribiendo programas con la función main (usada en todo
los programas). En el lenguaje C no hay diferencia entre una función y un
procedimiento, a decir verdad C no maneja el concepto de procedimiento como
otros lenguajes de programación. La noción de diferencia es sencilla, si devuelve
un valor entonces es una función, si no un procedimiento (función que no
devuelve un valor).

6.4. Definición de una función

La definición de una función ya se hizo anteriormente, sin embargo vale la pena


volverlo a hacer:

Sintaxis

<TipoDeDevolución> <NombreDeFunción> ( <TipoParamet ro>


<Parametro>, ..., <tipoParamentro> <Parametro>
<Cuerpo de la función>

El cuero de la función a menudo sigue el siguiente esquema

{
<Declaración de variables>
<Código a ejecutar>
return <expresión>
Me to do l o gí a de l a P ro g ram ació n I 60

El llamado de una función se hace mencionando el nombre

Ejemplo: Definición y Uso de la función área


/* NOMBRE: funarea.cpp */
INICIO
#include<iostream>
using namespace std;

float area( float b,float h) b,h


{
float a;
a=b*h/2; aßb*h/2
return a;
}
a

main()
{
float altura,base,areaTriangulo; FIN
cin>>base>>altura;
areaTriangulo=area(base,altura);
cout<<areaTriangulo;
}

Por lo general, en la definición de funciones se usa prototipos que no son más


que definiciones anticipadas de una función con ella el compilador puede
determinar el uso adecuado de funciones. En el ejemplo siguiente se muest ra el
mismo ejemplo anterior con la única diferencia de su prototipo que va después de
using namespace std . Por lo general para definir prototipos se recurre a otro
archivo denominado archivo cabecera (tiene extensión .h)

#include<iostream>
using namespac e std;

float area(float,float); /*Definicion prototipo de area */

float area( float b,float h)


{
float a;
a=b*h/2;
return a;
}
Me to do l o gí a de l a P ro g ram ació n I 61

main()
{
float altura,base,areaTriangulo;
cin>>base>>altura;
areaTriangulo=area( base,altura);
cout<<areaTriangulo;
}

Otra ventaja de usar prototipos es que la función se puede describir des pués de
que esta sea llamada.

Ejemplo: Funciones cubo y potencia


#include<iostream>
using namespace std;

float cubo(float); /*Prototipo*/

float potencia(float,float); /*Prototipo*/

main()
{
float a,b,c;
cin>>a;
cout<<cubo(a);
cin>>b>>c;
cout<<“ potencia ”<<potencia(b,c);
}

float cubo( float x)


{
return x*x*x;
}

float potencia( float x,float y)


{
float i,p;
i=1;
p=1;
while (i<=y) {
p=p*x;
i=i+1;
}
return p;
}
Me to do l o gí a de l a P ro g ram ació n I 62

Como se puede ver en el anterior ejemplo se usa en main aunque todavía no está
definida la función, si no se hubiera definido el prototipo no hubiese compilado,
porque el compilador todavía no conoce que existe una función cubo.

Ejemplo: El mayor de cinco números, si 6 8 4 3 2 el mayor es 8

#include<iostream>
using namespace std;

int mayor( int, int, int ); /* prototipo */

/* Funcion mayor */
int mayor( int a, int b, int c )
{
Int m;

m= a;
if ( b > m )
m = b;

if ( c > m )
m = c;

return m;
}

int main()
{
int x, y, z,u,v,may;

cout<<"Introducir cinco numeros : ";


cin>>x>>y>>z>>u>>v;
may=mayor(x,y,z);
may=mayor(may,u,v);
cout<<"Mayor es: "<< may;

return 0;
}

Complementariamente en el lenguaje C /C++ existen funciones de librería , es decir


funciones que se incorporan generalmente con el compilador, lo único que se
necesita es usarlo, así por ejemplo en casi todos los programas que se han
mostrado hasta el momento se ha usado para leer la función cin y para imprimir
Me to do l o gí a de l a P ro g ram ació n I 63

resultados la f unción cout. Ambas funciones son parte de la librería < iostream>.
Hay como ellas muchas librerias:
 stdlib.h Funciones estándar en general
 stdio.h Funciones estándar de entrada y salida
 math.h Funciones matemáticas
 io.h Funciones de entrada y salida
 string.h Funciones para el manejo de cadenas
 types.h Funciones para el manejo de tipos de datos

A continuación un programa que verifica las funciones matemáticas , para l a


salida, en vez de cout de la librería <iost ream>, se usa printf.

#include <stdio.h>
#include <math.h>
using namespace std;
int main()
{
printf( "sqrt(% .1f) = % .1f\n", 900.0, sqrt( 900.0 ) );
printf( "sqrt(% .1f) = % .1f\n", 9.0, sqrt( 9.0 ) );
printf( "exp(% .1f) = % f \n", 1.0, exp( 1.0 ) );
printf( "exp(% .1f) = % f \n", 2.0, exp( 2.0 ) );
printf( "log(% f) = % .1f \n", 2.718282, log( 2.718282 ) );
printf( "log(% f) = % .1f \n", 7.389056, log( 7.389056 ) );
printf( "log10(% .1f) = % .1f \n", 1.0, log10( 1.0 ) );
printf( "fabs(% .1f) = % .1f \n", 13.5, fabs( 13.5 ) );
printf( "fabs(% .1f) = % .1f \n", 0.0, fabs( 0.0 ) );
printf( "fabs(% .1f) = % .1f \n", -13.5, fabs( -13.5 ) );
printf( "ceil(% .1f) = % .1f \n", 9.2, ceil( 9.2 ) );
printf( "ceil(% .1f) = % .1f \n", -9.8, ceil( -9.8 ) );
printf( "floor(% .1f) = % .1f \n", 9.2, floor( 9.2 ) );
printf( "floor(% .1f) = % .1f \n", -9.8, floor( -9.8 ) );
printf( "pow(% .1f, % .1f) = % .1f \n", 2.0, 7.0, pow( 2.0, 7.0 ) );
printf( "pow(% .1f, % .1f) = % .1f \n", 9.0, 0.5, pow( 9.0, 0.5 ) );
printf( "fmod(% .3f/% .3f) = % .3f \n", 13.675, 2.333, fmod( 13.675, 2.333 ) );
printf( "sin(% .1f) = % .1f\n", 0.0, sin( 0.0 ) );
printf( "cos(% .1f) = % .1f \n", 0.0, cos( 0.0 ) );
printf( "tan(% .1f) = % .1f \n", 0.0, tan( 0.0 ) );
return 0;
}

6.5. Parámetros formales y actuales

Los parámetros formales son aquellos con los que se define la función. En la
función a son los parámetros formales b y h.
Me to do l o gí a de l a P ro g ram ació n I 64

float area( float b,float h)


{
float a;
a=b*h/2;
return a;
}
Los parámetros actuales son aquellos con los que se usa la función, es decir
aquell os para los cuales la función hace algo. Por ejemplo en el siguiente
segmento se usa la función area, con los parámetros altura y base. Esto significa
que con los valores de base y altura la función retornará un resultado que se
desea que haga. Aquí h y b se denominan parámetros actuales.

main()
{
float altura,base,areaTriangulo ;
cin>>base>>altura;
areaTriangulo=area( base,altura); /* h y b parametros actuales */
cout<<areaTriangulo;
}

6.6. Paso de parámetros

Cuando se llama a una función generalmente se debe hacerlo con determinados


parámetros, como considera la función estos parámetros se denomina paso de
parámetros. Existen dos formas: Paso por valor y paso por re ferencia.

Paso por valor: Los parámetros formales toman valores de los parámetros
actuales en la función. Hay una copia de los valores de parámetros actuales a los
formales. Es decir la función toma valores de los parámetros actuales. Los
ejemplos anteriores muestran el paso por valor.

Paso por referencia: Se dice que un parámetro se pasa por referencia cuando la
función recibe la dirección de memoria donde la variable que funciona como
parámetro actual reside realmente, y no el valor propiamente dicho. Y de esta
forma la función modifica el valor de los parámet ros actuales.

#include <stdio.h>
#include<iostream>
using namespace std;

void cubeRef( int * ); /* prototipo */

int main()
{
int numero = 5;
Me to do l o gí a de l a P ro g ram ació n I 65

printf( "El valor original de numero es % d", numero );


cubeRef( &numero );
printf( "\nEl nuevo valor de número es % d\n", numero );
return 0;
}
void cubeRef( int *nPtr )
{
*nPtr = *nPtr * *nPtr * *nPtr; /* cubo de numero de main */
}

En el programa (int *) significa que se trata de un puntero a entero. Cuando se


llama la función con &numero se da la dirección de la variable numero . Luego
*nPtr hace referencia al contenido de esa dirección.

6.7. Alcance o visibilidad

Las variables se clasifican en dos: Variables locales y variables globales

Variables locales: Es aquella que tiene vigencia solamente en el módulo, así si


existe una declarada en otro lugar con el mismo nombre será otra.

Variables Globales: Es aquella que tiene vigenc ia en todo el programa,


generalmente significa que también en los módulos del programa.

#include <stdio.h>
#include<iostream>
using namespace std;

void a( void ); /* prototipo */


void b( void ); /* prototipo */
void c( void ); /* prototipo */

int x = 1; /* variable global */

int main()
{
int x = 5; /* variable local a main */

printf("local de main x % d \n", x );


{ /* nuevo alcance */
int x = 7;

printf( "local x dentro de main % d\n", x );


} /* fin nuevo alcance */
Me to do l o gí a de l a P ro g ram ació n I 66

printf( "local en main de x % d \n", x );

a(); /* a tiene automatico local x */


b(); /* b tiene local static x */
c(); /* c usa global x */
a(); /* a reinicia automatico local x */
b(); /* static local x retiene su valor previo */
c(); /* global x tambien retiene su valor */
printf( "local de main x % d \n", x );
return 0;
}
Continuación.

void a( void )
{
int x = 25; /* inicializa cada vez que es llamado */

printf( "\nlocal x en a es % d al entrar a a \n", x );


++x;
printf( "local x en a es % d antes de salir de a \n", x );
}

void b( void )
{
static int x = 50; /* inicio estatico */
/* Primera vez solamente */
printf( "\nlocal static x es % d al entrar a b \n", x );
++x;
printf( "local static x es % d al salir de b \n", x );
}

void c( void )
{
printf( "\nglobal x es % d al entrar a c \n", x );
x *= 10;
printf( "global x es % d al salir de c \n", x );
}

6.8. Recursividad

Se refiere a una función que se llama a si misma, la recursividad como


concepto solo fue posible cuando se consideró variables locales.

Componentes para una función recurs iva:


Me to do l o gí a de l a P ro g ram ació n I 67

1. Caso base
2. Paso recursivo

El paso base es importante para que no se llame indefinidamente, el pas o 2 se


refiere a que se llama a si misma.

Ejemplo: Calcular el factorial de un número

#include <stdio.h>
#include<iostream>
using namespace std;

long factorial( long );

int main()
{
int i;
for ( i = 1; i <= 10; i++ )
printf( "% 2d! = % ld\n", i, factorial( i ) );
return 0;
}
long factorial( long numero )
{
if ( numero <= 1 ) /* Caso Base*/
return 1;
else
return ( numero * factorial( numero - 1 ) ); /*Paso recursivo*/
}

Ejemplo: Hallar la serie de Fibonacci


#include <stdio.h>
#include<iostream>
using namespace std;

long fibonacci( long );

int main()
{
long result, number;
printf( "Un entero: " );
scanf( "% ld", &number );
result = fibonacci( number );
Me to do l o gí a de l a P ro g ram ació n I 68

printf( "Fibonacci( % ld ) = % ld \n", number, result );


return 0;
}
/* Funcion fibonacci */
long fibonacci( long n )
{
if ( n == 0 || n == 1 )
return n;
else
return fibonacci( n - 1 ) + fibonac ci( n - 2 );
}

Ejercicios.

1. Construya una función que calcule la función exp


2. Construya una función que de el ordinal de un numero de 1 a 10
3. Construya una función que calcule el menor de tres números
4. Construya una función que calcule el mayor de cinco números
5. Construya una función que transforme minuscula a mayuscula.

También podría gustarte