- Funciones:
Las funciones pueden tomar parámetros que modifiquen su funcionamiento. Las funciones son utilizadas para descomponer grandes problemas en tareas simples y para implementar operaciones que son comúnmente utilizadas durante un programa y de esta manera reducir la cantidad de código.
- Estructura de datos:
para la estructura y un nombre para cada uno de sus miembros, sin olvidar los tipos de datos que estos representan. Generalmente, cada miembro se separa con algún tipo de operador, carácter o palabra reservada.
- Arreglo de parámetros:
permite guardar una relación de varios a uno: varios argumentos pueden ser representados por un único arreglo de parámetros. En otras palabras, los arreglos de parámetros permiten listas de argumentos de tamaño variable. se declara con el modificador params.
Sólo puede haber un arreglo de parámetros en cada método, y siempre debe ser el último parámetro especificado.
El tipo del arreglo de parámetros debe ser siempre un tipo arreglo unidimensional. Al llamar a la función se puede pasar uno o varios argumentos del tipo del arreglo.
Ejemplo de Arreglos como Parámetros:
Prog15.cpp
#include <stdio.h>
#include <conio.h>
#include <string.h>
void proc1(int vector[]);
void main() {
clrscr();
//creando arreglo y cargandolo
int lista[5]= {10,11,12,13,14};
// mandandolo a procedimiento recordar como se manda sin []
proc1(lista);
// desplegando arreglo lista y observar que datos salen
for(int reng=0; reng<=4; reng++)
printf("%d \n",lista[reng]);
getchar();
} // termina main
void proc1(int vector[])
{
// sumandole 50 a lo que se tenia en arreglo lista
// es decir vector queda cargado con 60,61,62,63,64
for(int reng=0; reng<=4; reng++)
vector[reng]=vector[reng]+ 50;
// observar que no se regresa nada
} //termina proc1
Es de recordar que los cambios que le
hagan al arreglo dentro de la función se reflejaran en el arreglo original,
es por esto que si se quiere modificar un arreglo en una función no hay
necesidad de regresar ningún valor.
|
- Registro como parámetros:
 |
| Imagen de Registro |
A-Ejemplo donde visualicen la conversión del programa estructurado en
programa modular utilizando las funciones:
/*Programa
que calcula y muestra el resultado de la suma, resta, mult o división de dos
números introducidos por el usuario, segun la opcion elegida*/
#include<stdio.h>
//Libreria estandar de entradas y salidas
#include<stdlib.h> //Libreria estandar.
float
num1, num2; //Variables globales num1 y num2
void
leer() //Definicion de la funcion leer
{ //Inicio del cuerpo de la funcion printf(“Ingrese valor 1: “); //Solicita el valor del primer dato scanf(“%f”,&num1); //Lee el dato y lo guarda en la variable num1 printf(“Ingrese valor 2: “); //Solicita el valor del segundo dato scanf(“%f”,&num2); //Lee el dato y lo guarda en la variable num2 } //Fin de la función
void
sumar() //Definicion de la funcion sumar
{ //Inicio del cuerpo de la funcion float suma; //Variable local suma suma = num1 + num2; //Operacion para calcular suma printf(“Suma = %.2f\n”,suma); //Imprime en pantalla el valor de suma } //Fin del cuerpo de la función
void
restar() //Definicion de la funcion restar
{ //Inicio del cuerpo de la funcion float resta; //Variable local resta resta = num1 – num2; //Operacion para calcular resta printf(“Resta = %.2f\n”,resta); //Imprime en pantalla el valor de resta } //Fin del cuerpo de la función
void
multiplicar() //Definicion de la funcion multiplicar
{ //Inicio del cuerpo de la funcion float mult; //Variable local mult mult = num1 * num2; //Operacion para calcular multiplicacion printf(“Multiplicacion = %.2f\n”,mult); //Imprime en pantalla el valor de mult } //Fin del cuerpo de la funcion
void
dividir() //Definicion de la funcion dividir
{ //Inicio del cuerpo de la funcion float div; //Variable local div
if
(num2==0) //Condicion: Si la variable num2 es igual a 0…
{ //Inicia el conjunto de sentencias a ejecutar en caso de cumplirse la condicion printf(“ERROR. Division por cero\n”); //Imprime en pantalla un mensaje de error system(“pause”); //Pausa la consola exit(0); //Salir } //Cierra el conjunto de sentencias a ejecutar en caso de cumplirse la condicion
else //En
caso de que no se cumpla la condicion…
{ //Inicia el conjunto de sentencias a ejecutar en caso de no cumplirse la condicion div = num1 / num2; //Operacion para calcular division printf(“Division = %.2f\n”,div); //Imprime en pantalla el valor de div } //Cierra el conjunto de sentencias a ejecutar en caso de no cumplirse la condicion } //Fin del cuerpo de la funcion
void
main() //Funcion principal
{ //Inicio int op; //Variable local op
leer();
//Llamada a la funcion leer
printf(“\nMENU\n”);
//Imprime en pantalla las opciones de menu
printf(“1. Sumar\n”); printf(“2. Restar\n”); printf(“3. Multiplicar\n”); printf(“4. Dividir\n”); printf(“Ingrese una opcion: “); //Solicita al usuario elegir una opcion scanf(“%d”,&op); //Lee el dato y lo guarda en la variable op printf(“\n”); //Salto de línea
switch(op)
//Sentencia switch. Estructura de control de seleccion
{ //Inicio de la sentencia switch
case 1:
//Caso 1
sumar(); //Llamada a la funcion sumar break; //Termina el caso 1
case 2:
//Caso 2
restar(); //Llamada a la funcion restar break; //Termina el caso 2
case 3:
//Caso 3
multiplicar(); //Llamada a la funcion multiplicar break; //Termina el caso 3
case 4:
//Caso 4
dividir(); //Llamada a la funcion dividir break; //Fin del caso 4
default:
//En caso de no cumplirse ninguno de los casos anteriores…
printf(“No es una opcion\n”); //…Imprimir un mensaje en pantalla. } //Fin de la sentencia switch system(“pause”); //Pausa la consola } //Fin |
B-Analizar la interrelación entre
las funciones y las estructuras de datos como parámetro de las funciones.
- Relación entre funciones y estructura de datos.
Cuando se llama a una función en c , los valores de los parámetros se copian desde el ámbito llamador (lugar en el que está la llamada a la función) al ámbito llamado (el cuerpo de la función). El siguiente programa muestra la ejecución de una función que recibe como parámetro dos estructuras.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
#include <stdio.h>
#include <math.h>
/* Definición de la estructura */
struct coordenadas
{
float x;
float y;
float z;
};
/* Definición de función que calcula la distancia entre dos puntos */
float distancia(struct coordenadas a, struct coordenadas b)
{
return sqrtf(pow(a.x - b.x, 2.0) +
pow(a.y - b.y, 2.0) +
pow(a.z - b.z, 2.0));
}
int main()
{
/* Declaración e inicialización de dos variables */
struct coordenadas punto_a = { 3.5e-120, 2.5, 1.5 };
struct coordenadas punto_b = { 5.3e-120, 3.1, 6.3 };
float d; /* Almacenar el resultado */
/* Llamada a la función con las dos estructuras */
d = distancia(punto_a, punto_b);
/* Imprimir el resultado */
printf("%f\n", d);
return 0;
}
|
En la línea 26 se realiza una
copia de las estructuras punto_a y punto_b en el ámbito de
la función main a las estructuras a y b en el
ámbito de la función distancia. Esta copia tiene dos efectos: el programa
invierte tanto tiempo como datos haya en la estructura, y durante la ejecución
de la función se mantienen en memoria dos copias completas de las estructuras.
El uso de punteros ofrece una alternativa más eficiente. La función puede
reescribirse para que reciba dos punteros a las estructuras. La definición
de la función pasa a ser:
float distancia(struct
coordenadas *a_ptr, struct coordenadas *b_ptr)
{
return sqrtf(pow(a_ptr->x - b_ptr->x,
2.0) +
pow(a_ptr->y - b_ptr->y,
2.0) +
pow(a_ptr->z - b_ptr->z,
2.0));
}
La llamada a la función en la línea 26
pasa ahora a ser
d = distancia(&punto_a, &punto_b);
Con esta nueva versión, el programa
ejecuta exactamente los mismos cálculos, obtiene el mismo resultado, pero su
ejecución es más rápida, y utiliza menos memoria.
C-Coloque
1 ejemplo de programación que involucren el uso de la funciones, estructuras de
datos y alguna técnica de diseño modular por ejemplo HIPO.
