Guía de Ejercicios

Profesora: Integrantes:
Gerlin Zurita. Reyes, Douglas. C.I.: 31.264.770.
Rodríguez, Isaac. C.I.: 30.696.020.
Rodríguez, Josthin. C.I.: 31.519.117.
Unidad Curricular: Algorítmica y programación. Ponce, Miguel. C.I.: 31.204.645.
Sección: IF05. Trayecto I. Fase I.

Sección IF05
Programación modular.

Una estrategia muy utilizada para la resolución de problemas complejos con la computadora, es la
división del problema en otros problemas más pequeños o subproblemas. Estos subproblemas se
implementarán mediante módulos o subprogramas.

Los subprogramas son una herramienta importante para el desarrollo de algoritmos y programas de
modo que normalmente un proyecto de programación está compuesto generalmente de un
programa principal y un conjunto de subprogramas con las llamadas a los mismos dentro del
programa principal.

Los subprogramas se clasifican en:

 Procedimientos
 Funciones

El diseño modular: subprogramas.

Estos problemas a su vez pueden ser divididos repetidamente en problemas más pequeños hasta que
los problemas más pequeños puedan ser solucionados.

Esta técnica de dividir el problema principal en subproblemas se denomina frecuentemente divide y

vencerás. El método de diseño se denomina diseño descendente, debido a que se comienza en la
parte superior con un problema general y se diseñan soluciones específicas a sus subproblemas.

Veamos un ejemplo de cómo emplear el diseño descendente para resolver un problema.

Supongamos que un profesor quiere crear un programa para gestionar las notas de sus alumnos.
Quiere que dicho programa le permita realizar tareas tales como asignar notas, cambiar notas, ver las
notas según distintas calificaciones, etc. A continuación se tiene un esquema que representa una de
las posibles divisiones del problema en módulos.

Procedimientos y funciones.

Procedimientos.

Un procedimiento es un subprograma que realiza una tarea específica. Puede recibir cero o más
valores del programa que llama (conocidos con el nombre de parámetros de entrada) y devolver cero
o más valores a dicho programa (conocidos como parámetros de salida).

Un procedimiento está compuesto por un grupo de sentencias al que se asigna un nombre de

procedimiento (identificador) y constituye una unidad de programa. La tarea determinada al
procedimiento se ejecuta siempre que se encuentra el nombre del procedimiento.

Declaración de procedimientos.

La forma de declarar un procedimiento es la siguiente:

Nomb_Proc(lista_ parámetros_entrada_y/o_salida)

Procesos
Fin Nomb_Proc

dónde:

Nomb_Proc : Nombre que se le da al procedimiento

Lista parámetros entrada y/o salida: Son los parámetros de entrada y/o salida necesarios para el
procedimiento.

Llamada a un procedimiento.

La forma de llamar a un procedimiento es:

C
Nomb_Proc(lista de parámetros)
Procesos
Fin
Precaución.

Los parámetros al momento de hacer la llamada al procedimiento deben coincidir en número, orden
y tipo con los parámetros de la declaración del mismo.

Funciones.

Una función es un subprograma que recibe como argumentos o parámetros, datos de tipos numérico
o no numérico, y devuelve un único resultado. Esta característica le diferencia esencialmente de un
procedimiento.

Declaración de funciones.

La forma de declarar un procedimiento es la siguiente:

Nomb_Func(lista_ parámetros_entrada)
Procesos
retornar(nomb_param_salida)

dónde:

Nomb_Func: Nombre que se le da a la función

Lista de parámetros entrada: Son los parámetros de entrada necesarios para la función

nomb_param_salida: Es el nombre de la variable que almacena el parámetro de salida o resultado de

la función.

Llamada a funciones

Una función es llamada por medio de su nombre, en una sentencia de asignación:

C
Procesos
nomb_var 􀃅 Nomb_Func(par1, par2, par3, …)
Fin

Diferencias entre procedimientos y funciones.

Los procedimientos y funciones son similares, aunque presentan notables diferencias entre ellos:

1. Las funciones normalmente, devuelven un solo valor a la unidad de programa (programa principal
u otro subprograma) que la referencia o la llama. Los procedimientos pueden devolver cero, uno o
varios valores. En el caso de no devolver ningún valor, realizan alguna tarea tal como operaciones de
entrada/salida.

2. A un nombre de procedimiento no se puede asignar un valor, y por consiguiente ningún tipo está
asociado con un nombre de procedimiento.

3. Una función se referencia utilizando su nombre en una instrucción (de asignación o expresión
matemática), mientras que un procedimiento se referencia por una llamada o invocación al mismo.

Definición de las funciones.

La definición de una función puede ubicarse en cualquier lugar del programa, con sólo dos
restricciones: debe hallarse luego de dar su prototipo, y no puede estar dentro de la definición de
otra función ( incluida main() ). Es decir que a diferencia de Pascal, en C las definiciones no pueden
anidarse.

La definición debe comenzar con un encabezamiento, que debe coincidir totalmente con el prototipo
declarado para la misma, y a continuación del mismo, encerradas por llaves se escribirán las
sentencias que la componen.

Ejemplo:

1)

#include <stdio.h>
/*********** DECLARACION observe que termina en ";" **********/
float Mi_Funcion(int i, double j );
/************* DEFINICION observe que NO lleva ";" *************/
float Mi_Funcion(int i, double j )
{
float n
...................
printf("%d", i ); /* LLAMADA a otra función */
Universidad Salesiana de Bolivia Ingeniería de Sistemas
Programación I 53 Dossier
return ( 2 * n ); /* RETORNO devolviendo un valor float */
}
/*********************** M A I N ************************/
void main()
{
float k ;
int p ;
double z ;
...........
k = Mi_Funcion( p, z ); /* LLAMADA a la función */
...........
} /* fin de la función main() */

Declaración de funciones.

Al igual que las variables, las funciones también han de ser declaradas. Esto es lo que se conoce como
prototipo de una función. Para que un programa en C sea compatible entre distintos compiladores es
imprescindible escribir los prototipos de las funciones.

Los prototipos de las funciones pueden escribirse antes de la función main o bien en otro archivo. En
este último caso se lo indicaremos al compilador mediante la directiva #include.

Ejemplos:

1. int cuadrado(int x);

2. void multiplica(int a, int b);
3. float suma(float a, float b);
4. int factorial(int x);j

Ámbito de las Variables.

Según el lugar donde son declaradas puede haber dos tipos de variables: globales o locales.

Variables globales.

Si definimos una variable FUERA de cualquier función (incluyendo a la función main()), estaremos
frente a lo que denominaremos VARIABLE GLOBAL. Este tipo de variable existirá todo el tiempo que
se esté ejecutando el programa. Se crean al iniciarse éste y se destruyen de la memoria al finalizar.
Este tipo de variables son automáticamente inicializadas a CERO cuando el programa comienza a
ejecutarse. Son accesibles a todas las funciones que estén declaradas en el mismo, por lo que
cualquiera de ellas podrá utilizarlas.

Variables locales.

A diferencia de las anteriores, las variables definidas DENTRO de una función, son denominadas
VARIABLES LOCALES a la misma, a veces se las denomina también como AUTOMÁTICAS, ya que son
creadas y destruidas automáticamente por la llamada y el retorno de una función, respectivamente.

El identificador ó nombre que se la haya dado a una variable es sólo relevante entonces, para la
función que la haya definido, pudiendo existir entonces variables que tengan el mismo nombre, pero
definidas en funciones distintas, sin que haya peligro alguno de confusión.
La ubicación de estas variables locales, se crea en el momento de correr el programa, por lo que no
poseen una dirección prefijada, esto impide que el compilador las pueda inicializar previamente.
Reacuérdese entonces que, si no se las inicializa expresamente en el momento de su definición, su
valor será indeterminado (basura).

El identificador (nombre de la variable) NO puede ser una palabra clave y los caracteres que
podemos utilizar son las letras: a-z y A-Z (ojo! la ñ o Ñ no está permitida), los números: 0-9 y el
símbolo de subrayado _. Además hay que tener en cuenta que el primer caracter no puede ser un
número.

Ejemplo:

Llamada a una función.

El llamado a una función, en el lenguaje C consiste en transferir el control a esa función. Cuando se
llama a esa función, se proporciona un nombre de función y una lista de parámetros, si es que los
hay. Cuando se llama a una función se realizan los siguientes pasos:

1. El compilador toma nota de la localización desde donde se llamó la función y hace una copia de la
lista de parámetros en caso de haberlos.

2. Se crea temporalmente cualquier espacio de almacenamiento que se requiere para ejecutar la

función.

3. Comienza la ejecución de la función que se llama, usando copias de los datos que se
proporcionaron en la lista de parámetros.

4. Después de que la función termina la ejecución, se regresa el control a la función que la llamo y se
libera memoria que se usó para la función.

Formato:

nomb_variable = nomb_función( parámetros actuales );

Dónde:

nomb_variable: Especifica el nombre de la variable en donde se guardará el valor devuelto por la

función

nomb_función: Especifica el nombre de la función a la que se está llamando.

Parámetros actuales: Son los valores que son pasados a la función y asignados a sus
correspondientes parámetros. El número de valores en la lista debe ser igual al número de
parámetros utilizados en la función y del mismo tipo.

Paso de parámetros a una función.

Por valor.

En este caso es el valor del parámetro el que se pasa a la función, de tal forma que los cambios que
se hagan en dicho valor no afectarán su valor original (variables de entrada).

Por referencia.

En este método es la dirección del parámetro el que se pasa a la función. Esto significa que los
cambios hechos al valor del parámetro permanecen incluso cuando la función ha terminado,
modificando de esta forma su valor original (variables de salida o de entrada/salida).

Ejemplos:

1. Llamada por valor:

#include <stdio.h>
#include <conio.h>
/***************** P R O T O T I P O S *****************/
int cuad(int x);
void Pausa(void);
/***************** D E F I N I C I O N *********************/
void Pausa(void)
{
printf("Presione cualquier tecla para continuar...");
getch();
}
/******************************************************/
int cuad(int x)
{
x = x*x;
return(x);
}
/***************** M A I N ********************/
int main(void)
{
int t = 10;
printf("El cuadrado de %d es %d \n\n", t, cuad(t));
Pausa();
return(0);
}

2. Llamada por referencia:

#include <stdio.h>
#include <conio.h>
/******************* P R O T O T I P O S ******************/
void inter(int *x, int *y);
void Pausa(void);
/******************* D E F I N I C I O N ******************/
void inter(int *x, int *y)
{
int aux;
aux = *x; /* guarda el valor de la variable x */
Universidad Salesiana de Bolivia Ingeniería de Sistemas
Programación I 59 Dossier
*x = *y; /* asigna el valor de y en x */
*y = aux; /* asigna en x el valor de y */
}
/********************************************************/
void Pausa(void)
{
printf("Presione cualquier tecla para continuar...");
getch();
}
/******************* M A I N ***********************/
int main(void)
{
int x, y;
clrscr();
x = 10;
y = 20;
system("cls");
printf("Antes x = %d e y = %d\n\n", x, y);
inter(&x,&y);
printf("Ahora x = %d e y = %d \n\n", x, y);
Pausa();
return(0);
}
 EJERCICIO A REALIZAR
Programa para calcular.

#include <stdio.h>
#include <stdlib.h>

#define MULTIPLICACION 1
#define RESTA 2
#define SUMA 3
#define POTENCIA 4
#define SALIR 5

void menuPrincipal();
void hacerMultiplicacion();
int main() //función main ó programa principal
{
int opcion;
do{
menuPrincipal();
printf("Dame la opcion: ");
scanf("%d",&opcion);
switch(opcion){
case MULTIPLICACION:
hacerMultiplicacion();
break;
case SALIR:
printf("bye bye\n");
break;
default:
printf("Proximamente profe, porque sino queda muy largo y usted no quiere un
mounstruo :D\n");
}
printf("Presione entrar para continuar");
getchar();
getchar();
}while(opcion!=SALIR);

return 0;
}
void menuPrincipal(){ //subrutina ó subprograma, sin parámetros
system("cls");
printf("CALCULADORA\n");
printf("Menu principal:\n");
printf("1. Multiplicacion\n");
printf("2. resta\n");
 printf("3. suma\n");
printf("4. potencia\n");
printf("5. salir\n");
}
void hacerMultiplicacion(){ //subrutina conocida como procedimiento, por ser void
int a,b,resultado;
printf("dame valor de a=");
scanf("%d",&a);
printf("dame valor de b=");
scanf("%d",&b);
resultado=a*b;
printf("el resultado es: %d\n",resultado);
}