Programacion Modular
Programacion Modular
Programacion Modular
Objetivo:
Conocer la programación modular y el manejo de funciones.
Comprender el manejo de parámetros de en las funciones.
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.
Calcular el area de un
triángulo
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).
Sintaxis
{
<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
main()
{
float altura,base,areaTriangulo; FIN
cin>>base>>altura;
areaTriangulo=area(base,altura);
cout<<areaTriangulo;
}
#include<iostream>
using namespac e std;
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.
main()
{
float a,b,c;
cin>>a;
cout<<cubo(a);
cin>>b>>c;
cout<<“ potencia ”<<potencia(b,c);
}
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.
#include<iostream>
using namespace std;
/* 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;
return 0;
}
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
#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;
}
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
main()
{
float altura,base,areaTriangulo ;
cin>>base>>altura;
areaTriangulo=area( base,altura); /* h y b parametros actuales */
cout<<areaTriangulo;
}
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;
int main()
{
int numero = 5;
Me to do l o gí a de l a P ro g ram ació n I 65
#include <stdio.h>
#include<iostream>
using namespace std;
int main()
{
int x = 5; /* variable local a main */
void a( void )
{
int x = 25; /* inicializa cada vez que es llamado */
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
1. Caso base
2. Paso recursivo
#include <stdio.h>
#include<iostream>
using namespace std;
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*/
}
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
Ejercicios.