Diseño de programación Top-Down
(ascendente-descendente)
Ahora en adelante se utilizará la estrategia “divide y
vencerás”, en donde se hará uso de sub-módulos que
permitan la resolución de los problemas de manera
ordenada.
Los beneficios de hacer uso de funciones o procedimientos,
con la estrategia “divide y vencerás”, principalmente son:
Aislar los problemas.
Desarrollar funciones o procedimientos
que resuelva un problema particular.
Dar mantenimiento a cada función de
manera rápida.
Efectuar pruebas del funcionamiento
correcto de cada función.
Reutilización de funciones.
Tipo de Módulos: Funciones y
procedimientos.
Una función es un conjunto de sentencias
(instrucciones) que cumplen un solo
propósito bien definido. Pueden recibir una
serie de parámetros que permitan
efectuar una serie de instrucciones y el
resultado generado es regresado por la
función en el punto en donde fue
invocada. Estas funciones pueden ser
invocadas (llamadas) por otras
funciones, como por ejemplo la función
principal (main).
La estructura de definición de una
función:
Análisis de la estructura de función en
Lenguaje C
Ejemplo:
/*Función suma de dos valores */
int suma ( int valorx, int valory )
{
int resultado;
resultado = valorx + valory;
return (resultado);
}
Procedimientos
Los procedimientos son ‘como’
funciones pero con la diferencia que
no regresan un resultado específico.
Un procedimiento tiene el objetivo
principal de desarrollar una serie de
instrucciones sin considerar un valor
de regreso.
Procedimientos
En el Lenguaje C, se hace uso de la
palabra reservada void, la cual indica
que el procedimiento (función) no
regresa valor alguno.
La estructura de definición de un
procedimiento
La estructura de invocación de
funciones y procedimientos:
Ejemplo:“Pirámide en Pantalla
con Procedimiento”
Pseudocódigo “Pinta_Piramide”
Pinta_Piramide_Proc ( )
Comienza
Escribir (“ * ”)
Escribir (“ *** ”)
Escribir (“ ***** ”)
Escribir (“*******”)
Termina
Principal ()
Comienza
Escribir (“Programa que imprime una pirámide:”)
Pinta_Piramide_Proc ()
Termina
Código en C
/*
Archivo: Pinta_Piramide.c
Descripción: Este programa manda a pantalla una representación de
una piramide de simbolos '*, haciendo uso de un Procedimiento.
Objetivo:
Utilización de Procedimiento para el envió de la información a pantalla
*/
/*Incluir librerías utilizadas en el programas*/
#include <stdio.h>
/*Documentación de Función o Procedimiento*/
void Pinta_Piramide_Proc( )
{
/*Declaración de variables locales*/
printf(" \n\n\t Inicio del Procedimiento Pinta_Piramide_Proc \n\n\n");
printf("\t\t * \n");
printf("\t\t *** \n");
printf("\t\t ***** \n");
printf("\t\t ******* \n");
}
Código en C
int main()
{
/*Declaración (e inicialización) de variables*/
printf("\t Programa Pinta Piramide \n\n ");
//Invocacion del Procedimiento
Pinta_Piramide_Proc( );
//¿Que pasa si se manda a invocar nuevamente la
función?
//Pinta_Piramide_Proc( );
getch();
return (0);
}
Parámetros
Algunas funciones (o procedimiento)
requieren de algunos parámetros para
poder efectuar una serie de
instrucciones. Un parámetro es un valor
que es ‘pasado’ a una función para
poder ser utilizado en la generación de
resultados. Estos parámetros se
clasifican en parámetros formales y
parámetros actuales.
Parámetros formales y
parámetros actuales
Los parámetros de la definición de la
función o procedimiento son llamados
parámetros formales, o comúnmente
parámetros.
Los parámetros de la invocación de la
función o procedimiento son llamados
parámetros actuales, o comúnmente
argumentos.
Los parámetros formales y actuales pueden
tener nombres distintos, en la definición de la
función es más generalizada que la
invocación. En la invocación es posible pasar
como argumentos valores específicos.
Es necesario contemplar algunas características
fundamentales del uso de los parámetros en funciones y
procedimientos, estás se describen a continuación:
Número de parámetros: Debe de ser el
mismo número de parámetros como de
argumentos.
Tipo de parámetro: el tipo de valor (o
variable) que se pasa como argumento en
la invocación de una función, deberá ser
compatible con el tipo de parámetro en la
definición de la función.
Orden en los parámetros: el orden los
parámetros deberá ser respetado en la
innovación de acuerdo a la definición de la
función o procedimiento.
Ejemplo:
Mayor de Tres Números
Desarrollar un programa que lea tres
números enteros positivos (mayores o
iguales a cero), y que se determine cual
es el mayor de los tres. Posteriormente
evalué cuales de los números leído son
pares.
Ejemplo
Pseudocódigo Principal
Principal ()
Comienza
valorUno=Leer_Entero ( )
valorDos=Leer_Entero ( )
valorTres=Leer_Entero ( )
Auxiliar =Mayor ( valorUno, valorDos )
mayorTodos=Mayor ( auxiliar , valorTres)
Escribir (“El mayor de todos es:” mayorTodos)
Auxiliar=Paridad ( valorUno )
Escribir_Paridad (valorUno,auxiliar)
Auxiliar=Paridad ( valorDos )
Escribir_Paridad (valorDos,auxiliar)
Auxiliar=Paridad ( valorTres )
Escribir_Paridad (valorTres,auxiliar)
Termina
Pseudocódigo Leer entero
Leer_Entero ()
Comienza
Repite
Comienza
Escribir (“Proporcione un número entero positivo:”)
Leer (valor)
Termina
Hasta ( valor < 0 )
Regresa ( valor )
Termina
Pseudocódigo Mayor
Mayor ( ValorA, ValorB )
Comienza
Si ( ValorA >= ValorB) entonces
Comienza
Auxiliar=ValorA
Termina
Otro
Comienza
Auxiliar=ValorB
Termina
Regresa (Auxiliar)
Termina
Pseudocódigo Paridad
Paridad ( Valor )
Comienza
Auxiliar =Valor mod 2
Si ( Auxiliar = 0 ) entonces
Comienza
Par=1
Termina
Otro
Comienza
Par=0
Termina
Regresa ( Par )
Termina
Pseudocódigo escribe paridad
Comienza
Si ( resultado = 1 ) entonces
Comienza
Escribir (“ El valor ”valor “es PAR”)
Termina
Otro
Comienza
Escribir (“ El valor ”valor “es IMPAR”)
Termina
Termina
Codificación en C
Código en C
/*
Archivo: Mayor_Tres.c
Descripción: Este programa hace uso de funciones para:
Leer un valor entero (positivo e incluyendo al cero).
Determinar cual es el mayor de dos valores.
Determinar si es par o impar un valor entero.
Escribir un mensaje de acuerdo a su paridad.
Dentro del programa invocar dichas funciones, de acuerdo a las
operaciones y mandar a imprimir el resultado.
Objetivo:
Utilización de Funciones para leer la información desde el teclado considerando la validación de la información,
también para hacer comparaciones, y determinar si es par.
Utilización de un Procedimiento para mandar a escribir un mensaje a pantalla.
Especificar el uso de variables dentro de cada uno de las funciones.
El uso parámetros y argumentos de las funciones y procedimientos.
*/
/*Incluir librerías utilizadas en el programas*/
#include <stdio.h>
/**
*Descripción: Función que leer un valor entero desde la consola, al momento que el usuario teclee un valor.
* Se hace uso de la estructura de control do...while para validar que
* el valor sea positivo (mayor o igual a 0)
* Entrada : nada
* Salida : valor leído desde el teclado.
**/
Continua código
int Leer_Entero()
{
int valor = 0;
do
{
printf("\n Escriba un numero entero positivo: ");
scanf("%d", &valor);
}while(valor < 0);
return (valor);
}
Continua código
/**
*Descripcion: Funcion que recibe como parametros dos valores enteros,
* para ser comparados entre si y determinar el mayor de ambos.
* Entrada : ValorA y ValorB, valores enteros.
* Salida : El mayor de los dos valores recibidos.
**/
int Mayor (int ValorA, int ValorB)
{
int Auxiliar = 0;
if( ValorA >= ValorB)
{
Auxiliar = ValorA;
}
else
{
Auxiliar = ValorB;
}
return (Auxiliar);
}
Continua código
/**
*Descripción: Función que recibe como parámetro un valor entero,
* para determinar si es par o impar, es decir, si es divisible
* entre 2. Esto se hace mediante el uso de la función modulo.
* Entrada : Valor de tipo entero que mantiene la cantidad a ser evaludada.
* Salida : El contenido de la variable Par:
* 1: si el Valor es par.
* 0: si el Valor es impar.
**/
int Paridad (int Valor)
{
Int Par = 0;
Int Auxiliar =0;
Auxiliar = Valor % 2;
//Verificacion de paridad
if(Auxiliar == 0)
{
Par = 1; //El valor de 1 indica que es Par
}
else
{
Par = 0; //El valor de 0 indica que es Impar
}
return (Par);
}
Continua código
/**
*Descripcion: Procedimiento que recibe como parametro un valor entero,
* y un Resultado que indica si el valor es par(1) o impar (0).
* De acuerdo al resultado se envia el tipo de mensaje.
* Entrada : -Valor: de tipo entero que mantiene uan COPIA de la informacion
* del valor original.
* -Resulatdo: DE tipo entero que especifica el resultado de la
* evaluacion de paridad.
* Salida : nada.
**/ void Escribir_Paridad (int Valor, int Resultado)
{
if(Resultado == 1 ) //Es par
{
printf("\nEl valor %d es PAR", Valor);
}
else //Es impar
{
printf("\nEl valor %d es IMPAR", Valor);
}
}
Continua código
/**Funcion pr incipal **/
Int main (int argc, char *argv[])
{
int ValorUno, ValorDos, ValorTres;
int auxiliar =0;
int mayorTodos=0;
printf("\t Programa Mayor de Tres \n ");
printf("\n Este programa permite la lectura de tres valores enteros
positivos\n ");
printf("para ser evaluados y detemrinar el mayor de los tres. Tambien se
determina \n");
printf("cuales valores son pares y cuales no. \n\n");
//Lectura de los tres valores desde teclado
ValorUno = Leer_Entero();
ValorDos = Leer_Entero();
ValorTres = Leer_Entero();
Continua código
//Determinar el mayor de ValorUno y ValorDos
auxiliar = Mayor (ValorUno, ValorDos);
//Determinar el mayor del resultado anterior con
el ValorTres
mayorTodos = Mayor (auxiliar, ValorTres);
printf ("\n\n El mayor de Todos es: %d\n\n",
mayorTodos);
//Analisis de paridad para el ValorUno
Paridad (ValorUno);
auxiliar = Escribir_Paridad (ValorUno ,
auxiliar);
Continua código
//Analisis de paridad para el ValorDos
auxiliar = Paridad (ValorDos);
Escribir_Paridad (ValorDos , auxiliar);
//Analisis de paridad para el ValorTres
auxiliar = Paridad (ValorTres);
Escribir_Paridad (ValorTres , auxiliar);
printf(" \n\n ");
system("PAUSE");
return(0);
}
